Winter Sales

Our seasonal collections evolve throughout the year. Discover LAFUMA outdoor furniture designed for comfort and durability, and check back for upcoming offers.


Zero Gravity Chairs and Recliners
Patio & Pool Furniture
Beach & Camping furniture
View all
BAYANNE RECLINER BAYANNE RECLINER
BAYANNE RECLINER
Bayanne Sunbrella® Granite
$499.99
$499.99
granite.png
RECLINING CHAIR BECOMFORT RECLINING CHAIR BECOMFORT
Sold out
RECLINING CHAIR BECOMFORT
Evolution Be Comfort® Dark grey
$449.99
$449.99
dark-grey.png
silver.png
RECLINING CHAIR RECLINING CHAIR
RECLINING CHAIR
Futura Air Comfort® Steel
$399.99
$399.99
steel.png
bordeaux.png
coral-blue.png
taupe.png
RECLINING CHAIR RECLINING CHAIR
Sold out
RECLINING CHAIR
Rclip Batyline® Iso Océan
$199.00
$199.00
ocean.png
chlorophylle.png
magnolia.png
seigle.png
+
RECLINING CHAIR RECLINING CHAIR
RECLINING CHAIR
Rsxa Clip Batyline® Iso Seigle
$299.90
$299.90
seigle.png
graphite.png
ocean-ii.png
moss.png
RECLINING CHAIR BECOMFORT RECLINING CHAIR BECOMFORT
RECLINING CHAIR BECOMFORT
Evolution Be Comfort® Silver
$449.99
$449.99
silver.png
dark-grey.png
RECLINING CHAIR RECLINING CHAIR
RECLINING CHAIR
Futura Batyline® Iso Moss
$299.00
$299.00
moss.png
ocean.png
seigle.png
graphite.png
INDOOR RECLINING CHAIR INDOOR RECLINING CHAIR
Sold out
INDOOR RECLINING CHAIR
Eclipse Stamskin Top Club Black
$499.00
$499.00
black.png
View all


<link href="//www.lafumausa.com/cdn/shop/t/51/assets/component-rating.css?v=24573085263941240431725370615" rel="stylesheet" type="text/css" media="all" />


<ax-product-card>
        <a href="/products/set-of-2-deckchairs-lounger-maxi-transat-batyline-iso-chlorophylle-tubing-titane"
           class="product-miniature product-card-wrapper card-wrapper underline-links-hover">
            <div class="card
      card--card
       card--media
       color-background-1 gradient
      
      
      "
                 style="--ratio-percent: 100.0%;"
            >
                <div class="card__inner  ratio"
                     style="--ratio-percent: 100.0%;"><div class="card__media card__media_secondary">
                            <div class="media media--square media--transparent">
                                
																 
																	<img lazy-src="//www.lafumausa.com/cdn/shop/files/MAXITRANSAT_Chlorophylle_1.jpg?v=1778076368&amp;width=550" alt="SET OF 2 DECKCHAIRS" lazy-srcset="//www.lafumausa.com/cdn/shop/files/MAXITRANSAT_Chlorophylle_1.jpg?v=1778076368&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/MAXITRANSAT_Chlorophylle_1.jpg?v=1778076368&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/MAXITRANSAT_Chlorophylle_1.jpg?v=1778076368&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/MAXITRANSAT_Chlorophylle_1.jpg?v=1778076368&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-primary">
																 
                                
<img lazy-src="//www.lafumausa.com/cdn/shop/products/LFM2502_9266_1_lounger-maxi-transat-batyline-iso-chlorophylle-tubing-titane.jpg?v=1679677922&amp;width=550" alt="SET OF 2 DECKCHAIRS" lazy-srcset="//www.lafumausa.com/cdn/shop/products/LFM2502_9266_1_lounger-maxi-transat-batyline-iso-chlorophylle-tubing-titane.jpg?v=1679677922&amp;width=180 180w, //www.lafumausa.com/cdn/shop/products/LFM2502_9266_1_lounger-maxi-transat-batyline-iso-chlorophylle-tubing-titane.jpg?v=1679677922&amp;width=220 220w, //www.lafumausa.com/cdn/shop/products/LFM2502_9266_1_lounger-maxi-transat-batyline-iso-chlorophylle-tubing-titane.jpg?v=1679677922&amp;width=330 330w, //www.lafumausa.com/cdn/shop/products/LFM2502_9266_1_lounger-maxi-transat-batyline-iso-chlorophylle-tubing-titane.jpg?v=1679677922&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-secondary">
</div>
                        </div><div class="card__content">
                        <div class="card__badge bottom left">
                            
                                
                                
                            
                                
                                
                            
</div>
                    </div>
                </div>
                <div class="card__content">
                    <div class="card__information">
                        
                            <div class="card__heading h5" id="title-template--25629764616504__ax_featured_collections_rFyreh-10683815788856">
                                SET OF 2 DECKCHAIRS
                            </div>
                            <div class="card__product__text">Maxi Transat Batyline® Iso Chlorophylle
                            </div>
                        
<span class="caption-large light"></span>
<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">
        $219.98
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Regular price</span>
          <s class="price-item price-item--regular">
            
              
            
          </s><span class="visually-hidden visually-hidden--inline">Sale price</span>
      <span class="price-item price-item--sale price-item--last">
        $219.98
      </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>
<div class="fake-variants"><div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9NQVhJVFJBTlNBVF9DaGxvcm9waHlsbGVfMS5qcGc/dj0xNzc4MDc2MzY4" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtYmF0eWxpbmUtaXNvLWNobG9yb3BoeWxsZS10dWJpbmctdGl0YW5l" data-badge="" data-available="true" data-price="21998" data-compare-price="" data-money-price="$219.98" data-money-compare="" data-subtitle="Maxi Transat Batyline® Iso Chlorophylle" class="fake-variant fake-variants__active">
				
				<img lazy-src="//www.lafumausa.com/cdn/shop/files/chlorophylle_small.png?v=9674715760202477033" alt="chlorophylle.png">
			</div>
		

<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9CVU5ETEVfTEZNMjUwMl85ODcwLmpwZz92PTE3MjQ4NTk3ODk=" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtYmF0eWxpbmUtaXNvLW9jZWFuLTItdHViaW5nLXRpdGFuZQ==" data-badge="" data-available="true" data-price="21998" data-compare-price="" data-money-price="$219.98" data-money-compare="" data-subtitle="Maxi Transat Batyline® Iso Ocean II">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/ocean-ii_small.png?v=2027260680570306790" alt="ocean-ii.png">
					</div>
				


<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9NQVhJVFJBTlNBVF9HcmFwaGl0ZV8xLmpwZz92PTE3NzgwNzU5MTE=" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtYmF0eWxpbmUtaXNvLWdyYXBoaXRlLXR1YmluZy10aXRhbmU=" data-badge="" data-available="true" data-price="21998" data-compare-price="" data-money-price="$219.98" data-money-compare="" data-subtitle="Maxi Transat Batyline® Iso Graphite">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/graphite_small.png?v=15937157868148701177" alt="graphite.png">
					</div>
				


<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9NQVhJVFJBTlNBVF9DZXJpc2llcl8xLmpwZz92PTE3NzgwNzYyMDM=" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtYmF0eWxpbmUtaXNvLWNlcmlzaWVyLXR1YmluZy10aXRhbmU=" data-badge="" data-available="true" data-price="21998" data-compare-price="" data-money-price="$219.98" data-money-compare="" data-subtitle="Maxi Transat Batyline® Iso Cerisier">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/cerisier_small.png?v=16471271331283387676" alt="cerisier.png">
					</div>
				

</div>
<div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--25629764616504__ax_featured_collections_rFyreh10683815788856" 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="52323808444728"
                                               disabled>
                                        <button
                                                id="quick-add-template--25629764616504__ax_featured_collections_rFyreh10683815788856-submit"
                                                type="submit"
                                                name="add"
                                                class="quick-add__submit btn btn-primary"
                                                aria-haspopup="dialog"
                                                aria-labelledby="quick-add-template--25629764616504__ax_featured_collections_rFyreh10683815788856-submit title-template--25629764616504__ax_featured_collections_rFyreh-10683815788856"
                                                aria-live="polite"
                                                data-sold-out-message="true"
                                                
                                        >
                    										<span class="quick-add__text">Add to bag
</span>
																				<span class="quick-add__icon hidden"><svg class="icon icon-cart" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 40">
  <g>
    <path d="M12.28,26.68A1.78,1.78,0,0,0,14,28H26a1.78,1.78,0,0,0,1.72-1.32l1.37-7.76A1.34,1.34,0,0,0,28,17.37l-.23,0H12.24a1.34,1.34,0,0,0-1.35,1.35,1.64,1.64,0,0,0,0,.23Z" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="14.17" y1="17.35" x2="17.29" y2="12" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="22.7" y1="12" x2="25.83" y2="17.35" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
  </g>
</svg>

</span>
                                        <span class="sold-out-message hidden">
                      										Sold out
                    										</span>
                                            <div class="loading-overlay__spinner hidden">
                                                <svg aria-hidden="true" focusable="false" role="presentation"
                                                     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="10683815788856" /><input type="hidden" name="section-id" value="template--25629764616504__ax_featured_collections_rFyreh" /></form></product-form></div></div>
            </div>
        </a>
    </ax-product-card>


<link href="//www.lafumausa.com/cdn/shop/t/51/assets/component-rating.css?v=24573085263941240431725370615" rel="stylesheet" type="text/css" media="all" />


<ax-product-card>
        <a href="/products/set-of-2-deckchairs-lounger-maxi-transat-batyline-iso-cerisier-tubing-titane"
           class="product-miniature product-card-wrapper card-wrapper underline-links-hover">
            <div class="card
      card--card
       card--media
       color-background-1 gradient
      
      
      "
                 style="--ratio-percent: 100.0%;"
            >
                <div class="card__inner  ratio"
                     style="--ratio-percent: 100.0%;"><div class="card__media card__media_secondary">
                            <div class="media media--square media--transparent">
                                
																 
																	<img lazy-src="//www.lafumausa.com/cdn/shop/files/MAXITRANSAT_Cerisier_1.jpg?v=1778076203&amp;width=550" alt="SET OF 2 DECKCHAIRS" lazy-srcset="//www.lafumausa.com/cdn/shop/files/MAXITRANSAT_Cerisier_1.jpg?v=1778076203&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/MAXITRANSAT_Cerisier_1.jpg?v=1778076203&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/MAXITRANSAT_Cerisier_1.jpg?v=1778076203&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/MAXITRANSAT_Cerisier_1.jpg?v=1778076203&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-primary">
																 
                                
<img lazy-src="//www.lafumausa.com/cdn/shop/files/LFM2502_9950_MAXI-TRANSAT_Cerisier_2.jpg?v=1759158990&amp;width=550" alt="SET OF 2 DECKCHAIRS" lazy-srcset="//www.lafumausa.com/cdn/shop/files/LFM2502_9950_MAXI-TRANSAT_Cerisier_2.jpg?v=1759158990&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/LFM2502_9950_MAXI-TRANSAT_Cerisier_2.jpg?v=1759158990&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/LFM2502_9950_MAXI-TRANSAT_Cerisier_2.jpg?v=1759158990&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/LFM2502_9950_MAXI-TRANSAT_Cerisier_2.jpg?v=1759158990&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-secondary">
</div>
                        </div><div class="card__content">
                        <div class="card__badge bottom left">
                            
                                
                                
                            
                                
                                
                            
</div>
                    </div>
                </div>
                <div class="card__content">
                    <div class="card__information">
                        
                            <div class="card__heading h5" id="title-template--25629764616504__ax_featured_collections_rFyreh-10683815592248">
                                SET OF 2 DECKCHAIRS
                            </div>
                            <div class="card__product__text">Maxi Transat Batyline® Iso Cerisier
                            </div>
                        
<span class="caption-large light"></span>
<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">
        $219.98
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Regular price</span>
          <s class="price-item price-item--regular">
            
              
            
          </s><span class="visually-hidden visually-hidden--inline">Sale price</span>
      <span class="price-item price-item--sale price-item--last">
        $219.98
      </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>
<div class="fake-variants"><div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9NQVhJVFJBTlNBVF9DZXJpc2llcl8xLmpwZz92PTE3NzgwNzYyMDM=" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtYmF0eWxpbmUtaXNvLWNlcmlzaWVyLXR1YmluZy10aXRhbmU=" data-badge="" data-available="true" data-price="21998" data-compare-price="" data-money-price="$219.98" data-money-compare="" data-subtitle="Maxi Transat Batyline® Iso Cerisier" class="fake-variant fake-variants__active">
				
				<img lazy-src="//www.lafumausa.com/cdn/shop/files/cerisier_small.png?v=16471271331283387676" alt="cerisier.png">
			</div>
		

<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9CVU5ETEVfTEZNMjUwMl85ODcwLmpwZz92PTE3MjQ4NTk3ODk=" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtYmF0eWxpbmUtaXNvLW9jZWFuLTItdHViaW5nLXRpdGFuZQ==" data-badge="" data-available="true" data-price="21998" data-compare-price="" data-money-price="$219.98" data-money-compare="" data-subtitle="Maxi Transat Batyline® Iso Ocean II">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/ocean-ii_small.png?v=2027260680570306790" alt="ocean-ii.png">
					</div>
				


<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9NQVhJVFJBTlNBVF9HcmFwaGl0ZV8xLmpwZz92PTE3NzgwNzU5MTE=" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtYmF0eWxpbmUtaXNvLWdyYXBoaXRlLXR1YmluZy10aXRhbmU=" data-badge="" data-available="true" data-price="21998" data-compare-price="" data-money-price="$219.98" data-money-compare="" data-subtitle="Maxi Transat Batyline® Iso Graphite">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/graphite_small.png?v=15937157868148701177" alt="graphite.png">
					</div>
				


<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9NQVhJVFJBTlNBVF9DaGxvcm9waHlsbGVfMS5qcGc/dj0xNzc4MDc2MzY4" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtYmF0eWxpbmUtaXNvLWNobG9yb3BoeWxsZS10dWJpbmctdGl0YW5l" data-badge="" data-available="true" data-price="21998" data-compare-price="" data-money-price="$219.98" data-money-compare="" data-subtitle="Maxi Transat Batyline® Iso Chlorophylle">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/chlorophylle_small.png?v=9674715760202477033" alt="chlorophylle.png">
					</div>
				

</div>
<div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--25629764616504__ax_featured_collections_rFyreh10683815592248" 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="52323796123960"
                                               disabled>
                                        <button
                                                id="quick-add-template--25629764616504__ax_featured_collections_rFyreh10683815592248-submit"
                                                type="submit"
                                                name="add"
                                                class="quick-add__submit btn btn-primary"
                                                aria-haspopup="dialog"
                                                aria-labelledby="quick-add-template--25629764616504__ax_featured_collections_rFyreh10683815592248-submit title-template--25629764616504__ax_featured_collections_rFyreh-10683815592248"
                                                aria-live="polite"
                                                data-sold-out-message="true"
                                                
                                        >
                    										<span class="quick-add__text">Add to bag
</span>
																				<span class="quick-add__icon hidden"><svg class="icon icon-cart" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 40">
  <g>
    <path d="M12.28,26.68A1.78,1.78,0,0,0,14,28H26a1.78,1.78,0,0,0,1.72-1.32l1.37-7.76A1.34,1.34,0,0,0,28,17.37l-.23,0H12.24a1.34,1.34,0,0,0-1.35,1.35,1.64,1.64,0,0,0,0,.23Z" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="14.17" y1="17.35" x2="17.29" y2="12" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="22.7" y1="12" x2="25.83" y2="17.35" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
  </g>
</svg>

</span>
                                        <span class="sold-out-message hidden">
                      										Sold out
                    										</span>
                                            <div class="loading-overlay__spinner hidden">
                                                <svg aria-hidden="true" focusable="false" role="presentation"
                                                     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="10683815592248" /><input type="hidden" name="section-id" value="template--25629764616504__ax_featured_collections_rFyreh" /></form></product-form></div></div>
            </div>
        </a>
    </ax-product-card>


<link href="//www.lafumausa.com/cdn/shop/t/51/assets/component-rating.css?v=24573085263941240431725370615" rel="stylesheet" type="text/css" media="all" />


<ax-product-card>
        <a href="/products/set-of-2-deckchairs-lounger-maxi-transat-colorblock-batyline-iso-canyon-tubing-canyon"
           class="product-miniature product-card-wrapper card-wrapper underline-links-hover">
            <div class="card
      card--card
       card--media
       color-background-1 gradient
      
      
      "
                 style="--ratio-percent: 100.0%;"
            >
                <div class="card__inner  ratio"
                     style="--ratio-percent: 100.0%;"><div class="card__media card__media_secondary">
                            <div class="media media--square media--transparent">
                                
																 
																	<img lazy-src="//www.lafumausa.com/cdn/shop/files/MAXITRANSATCOLORBLOCK_Canyon_1.jpg?v=1778074892&amp;width=550" alt="SET OF 2 DECKCHAIRS" lazy-srcset="//www.lafumausa.com/cdn/shop/files/MAXITRANSATCOLORBLOCK_Canyon_1.jpg?v=1778074892&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/MAXITRANSATCOLORBLOCK_Canyon_1.jpg?v=1778074892&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/MAXITRANSATCOLORBLOCK_Canyon_1.jpg?v=1778074892&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/MAXITRANSATCOLORBLOCK_Canyon_1.jpg?v=1778074892&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-primary">
																 
                                
<img lazy-src="//www.lafumausa.com/cdn/shop/products/LFM5170_9875_1_lounger-maxi-transat-colorblock-batyline-iso-canyon-tubing-canyon.jpg?v=1679677929&amp;width=550" alt="SET OF 2 DECKCHAIRS" lazy-srcset="//www.lafumausa.com/cdn/shop/products/LFM5170_9875_1_lounger-maxi-transat-colorblock-batyline-iso-canyon-tubing-canyon.jpg?v=1679677929&amp;width=180 180w, //www.lafumausa.com/cdn/shop/products/LFM5170_9875_1_lounger-maxi-transat-colorblock-batyline-iso-canyon-tubing-canyon.jpg?v=1679677929&amp;width=220 220w, //www.lafumausa.com/cdn/shop/products/LFM5170_9875_1_lounger-maxi-transat-colorblock-batyline-iso-canyon-tubing-canyon.jpg?v=1679677929&amp;width=330 330w, //www.lafumausa.com/cdn/shop/products/LFM5170_9875_1_lounger-maxi-transat-colorblock-batyline-iso-canyon-tubing-canyon.jpg?v=1679677929&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-secondary">
</div>
                        </div><div class="card__content">
                        <div class="card__badge bottom left">
                            
                                
                                
                            
                                
                                
                            
</div>
                    </div>
                </div>
                <div class="card__content">
                    <div class="card__information">
                        
                            <div class="card__heading h5" id="title-template--25629764616504__ax_featured_collections_rFyreh-10683776008504">
                                SET OF 2 DECKCHAIRS
                            </div>
                            <div class="card__product__text">Maxi Transat Batyline® Iso Canyon canyon
                            </div>
                        
<span class="caption-large light"></span>
<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">
        $219.98
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Regular price</span>
          <s class="price-item price-item--regular">
            
              
            
          </s><span class="visually-hidden visually-hidden--inline">Sale price</span>
      <span class="price-item price-item--sale price-item--last">
        $219.98
      </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>
<div class="fake-variants"><div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9NQVhJVFJBTlNBVENPTE9SQkxPQ0tfQ2FueW9uXzEuanBnP3Y9MTc3ODA3NDg5Mg==" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtY29sb3JibG9jay1iYXR5bGluZS1pc28tY2FueW9uLXR1YmluZy1jYW55b24=" data-badge="" data-available="true" data-price="21998" data-compare-price="" data-money-price="$219.98" data-money-compare="" data-subtitle="Maxi Transat Batyline® Iso Canyon canyon" class="fake-variant fake-variants__active">
				
				<img lazy-src="//www.lafumausa.com/cdn/shop/files/canyon-canyon_small.png?v=16978918801014132830" alt="canyon-canyon.png">
			</div>
		

<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9CVU5ETEVfTEZNNTE3MF85OTQwLmpwZz92PTE3MjQ4NjAwMTE=" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtY29sb3JibG9jay1iYXR5bGluZS1pc28taW5kaWdvLXR1YmluZy1pbmRpZ28=" data-badge="" data-available="true" data-price="21998" data-compare-price="" data-money-price="$219.98" data-money-compare="" data-subtitle="Maxi Transat Batyline® Iso Indigo indigo">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/indigo-indigo_small.png?v=9004787350335673744" alt="indigo-indigo.png">
					</div>
				


<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9NQVhJVFJBTlNBVF9Nb3NzXzEuanBnP3Y9MTc3ODA3NTA4OA==" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtY29sb3JibG9jay1iYXR5bGluZS1pc28tbW9zcy10dWJpbmctbW9zcw==" data-badge="PHNwYW4gY2xhc3M9ImJhZGdlIGJhZGdlLS1ib3R0b20tbGVmdCBjb2xvci1pbnZlcnNlIj5Tb2xkIG91dDwvc3Bhbj4=" data-available="false" data-price="21998" data-compare-price="" data-money-price="$219.98" data-money-compare="" data-subtitle="Maxi Transat Batyline® Iso Moss moss">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/moss-moss_small.png?v=5813533047511080129" alt="moss-moss.png">
					</div>
				


<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9NQVhJVFJBTlNBVENPTE9SQkxPQ0tfVGVycmVfMS5qcGc/dj0xNzc4MDc1MjU2" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtY29sb3JibG9jay1iYXR5bGluZS1pc28tdGVycmUtdHViaW5nLXRpdGFuZQ==" data-badge="" data-available="true" data-price="21998" data-compare-price="" data-money-price="$219.98" data-money-compare="" data-subtitle="Maxi Transat Batyline® Iso Terre titane">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/terre-titane_small.png?v=18206695080888077063" alt="terre-titane.png">
					</div>
				


<div class="fake-variants__more">+</div></div>
<div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--25629764616504__ax_featured_collections_rFyreh10683776008504" 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="52323638116664"
                                               disabled>
                                        <button
                                                id="quick-add-template--25629764616504__ax_featured_collections_rFyreh10683776008504-submit"
                                                type="submit"
                                                name="add"
                                                class="quick-add__submit btn btn-primary"
                                                aria-haspopup="dialog"
                                                aria-labelledby="quick-add-template--25629764616504__ax_featured_collections_rFyreh10683776008504-submit title-template--25629764616504__ax_featured_collections_rFyreh-10683776008504"
                                                aria-live="polite"
                                                data-sold-out-message="true"
                                                
                                        >
                    										<span class="quick-add__text">Add to bag
</span>
																				<span class="quick-add__icon hidden"><svg class="icon icon-cart" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 40">
  <g>
    <path d="M12.28,26.68A1.78,1.78,0,0,0,14,28H26a1.78,1.78,0,0,0,1.72-1.32l1.37-7.76A1.34,1.34,0,0,0,28,17.37l-.23,0H12.24a1.34,1.34,0,0,0-1.35,1.35,1.64,1.64,0,0,0,0,.23Z" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="14.17" y1="17.35" x2="17.29" y2="12" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="22.7" y1="12" x2="25.83" y2="17.35" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
  </g>
</svg>

</span>
                                        <span class="sold-out-message hidden">
                      										Sold out
                    										</span>
                                            <div class="loading-overlay__spinner hidden">
                                                <svg aria-hidden="true" focusable="false" role="presentation"
                                                     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="10683776008504" /><input type="hidden" name="section-id" value="template--25629764616504__ax_featured_collections_rFyreh" /></form></product-form></div></div>
            </div>
        </a>
    </ax-product-card>


<link href="//www.lafumausa.com/cdn/shop/t/51/assets/component-rating.css?v=24573085263941240431725370615" rel="stylesheet" type="text/css" media="all" />


<ax-product-card>
        <a href="/products/design-chair-pop-up-xl-airlon-curry"
           class="product-miniature product-card-wrapper card-wrapper underline-links-hover">
            <div class="card
      card--card
       card--media
       color-background-1 gradient
      
      
      "
                 style="--ratio-percent: 100.0%;"
            >
                <div class="card__inner  ratio"
                     style="--ratio-percent: 100.0%;"><div class="card__media card__media_secondary">
                            <div class="media media--square media--transparent">
                                
																 
																	<img lazy-src="//www.lafumausa.com/cdn/shop/products/LFM2777_7234_design-chair-pop-up-xl-airlon-curry.jpg?v=1761574453&amp;width=550" alt="DESIGN CHAIR" lazy-srcset="//www.lafumausa.com/cdn/shop/products/LFM2777_7234_design-chair-pop-up-xl-airlon-curry.jpg?v=1761574453&amp;width=180 180w, //www.lafumausa.com/cdn/shop/products/LFM2777_7234_design-chair-pop-up-xl-airlon-curry.jpg?v=1761574453&amp;width=220 220w, //www.lafumausa.com/cdn/shop/products/LFM2777_7234_design-chair-pop-up-xl-airlon-curry.jpg?v=1761574453&amp;width=330 330w, //www.lafumausa.com/cdn/shop/products/LFM2777_7234_design-chair-pop-up-xl-airlon-curry.jpg?v=1761574453&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-primary">
																 
                                
<img lazy-src="//www.lafumausa.com/cdn/shop/products/LFM2777_7234_1_design-chair-pop-up-xl-airlon-curry.jpg?v=1679677874&amp;width=550" alt="DESIGN CHAIR" lazy-srcset="//www.lafumausa.com/cdn/shop/products/LFM2777_7234_1_design-chair-pop-up-xl-airlon-curry.jpg?v=1679677874&amp;width=180 180w, //www.lafumausa.com/cdn/shop/products/LFM2777_7234_1_design-chair-pop-up-xl-airlon-curry.jpg?v=1679677874&amp;width=220 220w, //www.lafumausa.com/cdn/shop/products/LFM2777_7234_1_design-chair-pop-up-xl-airlon-curry.jpg?v=1679677874&amp;width=330 330w, //www.lafumausa.com/cdn/shop/products/LFM2777_7234_1_design-chair-pop-up-xl-airlon-curry.jpg?v=1679677874&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-secondary">
</div>
                        </div><div class="card__content">
                        <div class="card__badge bottom left">
                            
                                
                                
                            
                                
                                
                            
                                
                                    <span class="badge badge--bottom-left color-accent-1">XL</span>
                                
                                
                            

                                <span class="badge badge--bottom-left color-inverse">Sold out</span></div>
                    </div>
                </div>
                <div class="card__content">
                    <div class="card__information">
                        
                            <div class="card__heading h5" id="title-template--25629764616504__ax_featured_collections_rFyreh-8204762480952">
                                DESIGN CHAIR
                            </div>
                            <div class="card__product__text">Pop Up XL Airlon Curry
                            </div>
                        
<span class="caption-large light"></span>
<div class="price  price--sold-out ">
  <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">
        $149.99
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Regular price</span>
          <s class="price-item price-item--regular">
            
              
            
          </s><span class="visually-hidden visually-hidden--inline">Sale price</span>
      <span class="price-item price-item--sale price-item--last">
        $149.99
      </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>
<div class="fake-variants"><div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9wcm9kdWN0cy9MRk0yNzc3XzcyMzRfZGVzaWduLWNoYWlyLXBvcC11cC14bC1haXJsb24tY3VycnkuanBnP3Y9MTc2MTU3NDQ1Mw==" data-obfuscated-url="L3Byb2R1Y3RzL2Rlc2lnbi1jaGFpci1wb3AtdXAteGwtYWlybG9uLWN1cnJ5" data-badge="PHNwYW4gY2xhc3M9ImJhZGdlIGJhZGdlLS1ib3R0b20tbGVmdCBjb2xvci1hY2NlbnQtMSI+WEw8L3NwYW4+PHNwYW4gY2xhc3M9ImJhZGdlIGJhZGdlLS1ib3R0b20tbGVmdCBjb2xvci1pbnZlcnNlIj5Tb2xkIG91dDwvc3Bhbj4=" data-available="false" data-price="14999" data-compare-price="" data-money-price="$149.99" data-money-compare="" data-subtitle="Pop Up XL Airlon Curry" class="fake-variant fake-variants__active">
				
				<img lazy-src="//www.lafumausa.com/cdn/shop/files/curry_small.png?v=16725540303413219730" alt="curry.png">
			</div>
		

<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9wcm9kdWN0cy9MRk0yNzc3XzkzMjhfZGVzaWduLWNoYWlyLXBvcC11cC14bC1haXJsb24tZWNydS10dWJpbmctbm9pci5qcGc/dj0xNjc5Njc3ODg5" data-obfuscated-url="L3Byb2R1Y3RzL2Rlc2lnbi1jaGFpci1wb3AtdXAteGwtYWlybG9uLWVjcnUtdHViaW5nLW5vaXI=" data-badge="PHNwYW4gY2xhc3M9ImJhZGdlIGJhZGdlLS1ib3R0b20tbGVmdCBjb2xvci1hY2NlbnQtMSI+WEw8L3NwYW4+" data-available="true" data-price="14999" data-compare-price="" data-money-price="$149.99" data-money-compare="" data-subtitle="Pop Up XL Airlon Ecru">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/ecru_small.png?v=16796405245943890270" alt="ecru.png">
					</div>
				


<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9wcm9kdWN0cy9MRk0yNzc3XzY1MzVfZGVzaWduLWNoYWlyLXBvcC11cC14bC1haXJsb24tZ3Jlcy5qcGc/dj0xNjc5Njc3ODg3" data-obfuscated-url="L3Byb2R1Y3RzL2Rlc2lnbi1jaGFpci1wb3AtdXAteGwtYWlybG9uLWdyZXM=" data-badge="PHNwYW4gY2xhc3M9ImJhZGdlIGJhZGdlLS1ib3R0b20tbGVmdCBjb2xvci1hY2NlbnQtMSI+WEw8L3NwYW4+" data-available="true" data-price="14999" data-compare-price="" data-money-price="$149.99" data-money-compare="" data-subtitle="Pop Up XL Airlon Grès">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/gres_small.png?v=8029192990772203535" alt="gres.png">
					</div>
				


<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9wcm9kdWN0cy9MRk0yNzc3XzY1MzRfZGVzaWduLWNoYWlyLXBvcC11cC14bC1haXJsb24tZ2FyYW5jZS5qcGc/dj0xNjc5Njc3ODg2" data-obfuscated-url="L3Byb2R1Y3RzL2Rlc2lnbi1jaGFpci1wb3AtdXAteGwtYWlybG9uLWdhcmFuY2U=" data-badge="PHNwYW4gY2xhc3M9ImJhZGdlIGJhZGdlLS1ib3R0b20tbGVmdCBjb2xvci1hY2NlbnQtMSI+WEw8L3NwYW4+" data-available="true" data-price="14999" data-compare-price="" data-money-price="$149.99" data-money-compare="" data-subtitle="Pop Up XL Airlon Garance">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/garance_small.png?v=17843085230204333752" alt="garance.png">
					</div>
				

</div>
<div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--25629764616504__ax_featured_collections_rFyreh8204762480952" 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="44814903214392"
                                               disabled>
                                        <button
                                                id="quick-add-template--25629764616504__ax_featured_collections_rFyreh8204762480952-submit"
                                                type="submit"
                                                name="add"
                                                class="quick-add__submit btn btn-primary"
                                                aria-haspopup="dialog"
                                                aria-labelledby="quick-add-template--25629764616504__ax_featured_collections_rFyreh8204762480952-submit title-template--25629764616504__ax_featured_collections_rFyreh-8204762480952"
                                                aria-live="polite"
                                                data-sold-out-message="true"
                                                disabled
                                        >
                    										<span class="quick-add__text">Sold out
</span>
																				<span class="quick-add__icon hidden"><svg class="icon icon-cart" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 40">
  <g>
    <path d="M12.28,26.68A1.78,1.78,0,0,0,14,28H26a1.78,1.78,0,0,0,1.72-1.32l1.37-7.76A1.34,1.34,0,0,0,28,17.37l-.23,0H12.24a1.34,1.34,0,0,0-1.35,1.35,1.64,1.64,0,0,0,0,.23Z" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="14.17" y1="17.35" x2="17.29" y2="12" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="22.7" y1="12" x2="25.83" y2="17.35" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
  </g>
</svg>

</span>
                                        <span class="sold-out-message hidden">
                      										Sold out
                    										</span>
                                            <div class="loading-overlay__spinner hidden">
                                                <svg aria-hidden="true" focusable="false" role="presentation"
                                                     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="8204762480952" /><input type="hidden" name="section-id" value="template--25629764616504__ax_featured_collections_rFyreh" /></form></product-form></div></div>
            </div>
        </a>
    </ax-product-card>


<link href="//www.lafumausa.com/cdn/shop/t/51/assets/component-rating.css?v=24573085263941240431725370615" rel="stylesheet" type="text/css" media="all" />


<ax-product-card>
        <a href="/products/set-of-2-deckchairs-lounger-maxi-transat-striped-airlon-miel-tubing-miel"
           class="product-miniature product-card-wrapper card-wrapper underline-links-hover">
            <div class="card
      card--card
       card--media
       color-background-1 gradient
      
      
      "
                 style="--ratio-percent: 100.0%;"
            >
                <div class="card__inner  ratio"
                     style="--ratio-percent: 100.0%;"><div class="card__media card__media_secondary">
                            <div class="media media--square media--transparent">
                                
																 
																	<img lazy-src="//www.lafumausa.com/cdn/shop/files/MAXITRANSATRAYURES_Miel_1.jpg?v=1778076678&amp;width=550" alt="SET OF 2 DECKCHAIRS" lazy-srcset="//www.lafumausa.com/cdn/shop/files/MAXITRANSATRAYURES_Miel_1.jpg?v=1778076678&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/MAXITRANSATRAYURES_Miel_1.jpg?v=1778076678&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/MAXITRANSATRAYURES_Miel_1.jpg?v=1778076678&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/MAXITRANSATRAYURES_Miel_1.jpg?v=1778076678&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-primary">
																 
                                
<img lazy-src="//www.lafumausa.com/cdn/shop/files/LFM5393_A002_MAXI-TRANSAT-RAYURE_Miel_2.jpg?v=1776355095&amp;width=550" alt="SET OF 2 DECKCHAIRS" lazy-srcset="//www.lafumausa.com/cdn/shop/files/LFM5393_A002_MAXI-TRANSAT-RAYURE_Miel_2.jpg?v=1776355095&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/LFM5393_A002_MAXI-TRANSAT-RAYURE_Miel_2.jpg?v=1776355095&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/LFM5393_A002_MAXI-TRANSAT-RAYURE_Miel_2.jpg?v=1776355095&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/LFM5393_A002_MAXI-TRANSAT-RAYURE_Miel_2.jpg?v=1776355095&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-secondary">
</div>
                        </div><div class="card__content">
                        <div class="card__badge bottom left">
                            
                                
                                
                            
                                
                                
                            
</div>
                    </div>
                </div>
                <div class="card__content">
                    <div class="card__information">
                        
                            <div class="card__heading h5" id="title-template--25629764616504__ax_featured_collections_rFyreh-10683816902968">
                                SET OF 2 DECKCHAIRS
                            </div>
                            <div class="card__product__text">Maxi Transat Airlon Miel striped
                            </div>
                        
<span class="caption-large light"></span>
<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">
        $239.98
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Regular price</span>
          <s class="price-item price-item--regular">
            
              
            
          </s><span class="visually-hidden visually-hidden--inline">Sale price</span>
      <span class="price-item price-item--sale price-item--last">
        $239.98
      </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>
<div class="fake-variants"><div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9NQVhJVFJBTlNBVFJBWVVSRVNfTWllbF8xLmpwZz92PTE3NzgwNzY2Nzg=" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtc3RyaXBlZC1haXJsb24tbWllbC10dWJpbmctbWllbA==" data-badge="" data-available="true" data-price="23998" data-compare-price="" data-money-price="$239.98" data-money-compare="" data-subtitle="Maxi Transat Airlon Miel striped" class="fake-variant fake-variants__active">
				
				<img lazy-src="//www.lafumausa.com/cdn/shop/files/miel-striped_small.png?v=1576242611408703135" alt="miel-striped.png">
			</div>
		

<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9NQVhJVFJBTlNBVFJBWVVSRVNfTW9zc18xLmpwZz92PTE3NzgwNzY1Mjg=" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtc3RyaXBlZC1haXJsb24tbW9zcy10dWJpbmctbW9zcw==" data-badge="" data-available="true" data-price="23998" data-compare-price="" data-money-price="$239.98" data-money-compare="" data-subtitle="Maxi Transat Airlon Moss striped">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/moss-striped_small.png?v=446482300662613006" alt="moss-striped.png">
					</div>
				


<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9NQVhJVFJBTlNBVFJBWVVSRVNfSW5kaWdvXzEuanBnP3Y9MTc3ODA3Njg0MA==" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtc3RyaXBlZC1haXJsb24taW5kaWdvLXR1YmluZy1pbmRpZ28=" data-badge="" data-available="true" data-price="23998" data-compare-price="" data-money-price="$239.98" data-money-compare="" data-subtitle="Maxi Transat Airlon Indigo striped">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/indigo-striped_small.png?v=7302879863266739431" alt="indigo-striped.png">
					</div>
				

</div>
<div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--25629764616504__ax_featured_collections_rFyreh10683816902968" 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="52323827679544"
                                               disabled>
                                        <button
                                                id="quick-add-template--25629764616504__ax_featured_collections_rFyreh10683816902968-submit"
                                                type="submit"
                                                name="add"
                                                class="quick-add__submit btn btn-primary"
                                                aria-haspopup="dialog"
                                                aria-labelledby="quick-add-template--25629764616504__ax_featured_collections_rFyreh10683816902968-submit title-template--25629764616504__ax_featured_collections_rFyreh-10683816902968"
                                                aria-live="polite"
                                                data-sold-out-message="true"
                                                
                                        >
                    										<span class="quick-add__text">Add to bag
</span>
																				<span class="quick-add__icon hidden"><svg class="icon icon-cart" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 40">
  <g>
    <path d="M12.28,26.68A1.78,1.78,0,0,0,14,28H26a1.78,1.78,0,0,0,1.72-1.32l1.37-7.76A1.34,1.34,0,0,0,28,17.37l-.23,0H12.24a1.34,1.34,0,0,0-1.35,1.35,1.64,1.64,0,0,0,0,.23Z" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="14.17" y1="17.35" x2="17.29" y2="12" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="22.7" y1="12" x2="25.83" y2="17.35" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
  </g>
</svg>

</span>
                                        <span class="sold-out-message hidden">
                      										Sold out
                    										</span>
                                            <div class="loading-overlay__spinner hidden">
                                                <svg aria-hidden="true" focusable="false" role="presentation"
                                                     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="10683816902968" /><input type="hidden" name="section-id" value="template--25629764616504__ax_featured_collections_rFyreh" /></form></product-form></div></div>
            </div>
        </a>
    </ax-product-card>


<link href="//www.lafumausa.com/cdn/shop/t/51/assets/component-rating.css?v=24573085263941240431725370615" rel="stylesheet" type="text/css" media="all" />


<ax-product-card>
        <a href="/products/set-of-2-deckchairs-lounger-maxi-transat-striped-airlon-moss-tubing-moss"
           class="product-miniature product-card-wrapper card-wrapper underline-links-hover">
            <div class="card
      card--card
       card--media
       color-background-1 gradient
      
      
      "
                 style="--ratio-percent: 100.0%;"
            >
                <div class="card__inner  ratio"
                     style="--ratio-percent: 100.0%;"><div class="card__media card__media_secondary">
                            <div class="media media--square media--transparent">
                                
																 
																	<img lazy-src="//www.lafumausa.com/cdn/shop/files/MAXITRANSATRAYURES_Moss_1.jpg?v=1778076528&amp;width=550" alt="SET OF 2 DECKCHAIRS" lazy-srcset="//www.lafumausa.com/cdn/shop/files/MAXITRANSATRAYURES_Moss_1.jpg?v=1778076528&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/MAXITRANSATRAYURES_Moss_1.jpg?v=1778076528&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/MAXITRANSATRAYURES_Moss_1.jpg?v=1778076528&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/MAXITRANSATRAYURES_Moss_1.jpg?v=1778076528&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-primary">
																 
                                
<img lazy-src="//www.lafumausa.com/cdn/shop/files/LFM5393_A000_MAXI-TRANSAT-RAYURE_Moss_2.jpg?v=1776355097&amp;width=550" alt="SET OF 2 DECKCHAIRS" lazy-srcset="//www.lafumausa.com/cdn/shop/files/LFM5393_A000_MAXI-TRANSAT-RAYURE_Moss_2.jpg?v=1776355097&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/LFM5393_A000_MAXI-TRANSAT-RAYURE_Moss_2.jpg?v=1776355097&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/LFM5393_A000_MAXI-TRANSAT-RAYURE_Moss_2.jpg?v=1776355097&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/LFM5393_A000_MAXI-TRANSAT-RAYURE_Moss_2.jpg?v=1776355097&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-secondary">
</div>
                        </div><div class="card__content">
                        <div class="card__badge bottom left">
                            
                                
                                
                            
                                
                                
                            
</div>
                    </div>
                </div>
                <div class="card__content">
                    <div class="card__information">
                        
                            <div class="card__heading h5" id="title-template--25629764616504__ax_featured_collections_rFyreh-10683816313144">
                                SET OF 2 DECKCHAIRS
                            </div>
                            <div class="card__product__text">Maxi Transat Airlon Moss striped
                            </div>
                        
<span class="caption-large light"></span>
<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">
        $239.98
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Regular price</span>
          <s class="price-item price-item--regular">
            
              
            
          </s><span class="visually-hidden visually-hidden--inline">Sale price</span>
      <span class="price-item price-item--sale price-item--last">
        $239.98
      </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>
<div class="fake-variants"><div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9NQVhJVFJBTlNBVFJBWVVSRVNfTW9zc18xLmpwZz92PTE3NzgwNzY1Mjg=" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtc3RyaXBlZC1haXJsb24tbW9zcy10dWJpbmctbW9zcw==" data-badge="" data-available="true" data-price="23998" data-compare-price="" data-money-price="$239.98" data-money-compare="" data-subtitle="Maxi Transat Airlon Moss striped" class="fake-variant fake-variants__active">
				
				<img lazy-src="//www.lafumausa.com/cdn/shop/files/moss-striped_small.png?v=446482300662613006" alt="moss-striped.png">
			</div>
		

<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9NQVhJVFJBTlNBVFJBWVVSRVNfTWllbF8xLmpwZz92PTE3NzgwNzY2Nzg=" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtc3RyaXBlZC1haXJsb24tbWllbC10dWJpbmctbWllbA==" data-badge="" data-available="true" data-price="23998" data-compare-price="" data-money-price="$239.98" data-money-compare="" data-subtitle="Maxi Transat Airlon Miel striped">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/miel-striped_small.png?v=1576242611408703135" alt="miel-striped.png">
					</div>
				


<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9NQVhJVFJBTlNBVFJBWVVSRVNfSW5kaWdvXzEuanBnP3Y9MTc3ODA3Njg0MA==" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtc3RyaXBlZC1haXJsb24taW5kaWdvLXR1YmluZy1pbmRpZ28=" data-badge="" data-available="true" data-price="23998" data-compare-price="" data-money-price="$239.98" data-money-compare="" data-subtitle="Maxi Transat Airlon Indigo striped">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/indigo-striped_small.png?v=7302879863266739431" alt="indigo-striped.png">
					</div>
				

</div>
<div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--25629764616504__ax_featured_collections_rFyreh10683816313144" 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="52323823321400"
                                               disabled>
                                        <button
                                                id="quick-add-template--25629764616504__ax_featured_collections_rFyreh10683816313144-submit"
                                                type="submit"
                                                name="add"
                                                class="quick-add__submit btn btn-primary"
                                                aria-haspopup="dialog"
                                                aria-labelledby="quick-add-template--25629764616504__ax_featured_collections_rFyreh10683816313144-submit title-template--25629764616504__ax_featured_collections_rFyreh-10683816313144"
                                                aria-live="polite"
                                                data-sold-out-message="true"
                                                
                                        >
                    										<span class="quick-add__text">Add to bag
</span>
																				<span class="quick-add__icon hidden"><svg class="icon icon-cart" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 40">
  <g>
    <path d="M12.28,26.68A1.78,1.78,0,0,0,14,28H26a1.78,1.78,0,0,0,1.72-1.32l1.37-7.76A1.34,1.34,0,0,0,28,17.37l-.23,0H12.24a1.34,1.34,0,0,0-1.35,1.35,1.64,1.64,0,0,0,0,.23Z" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="14.17" y1="17.35" x2="17.29" y2="12" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="22.7" y1="12" x2="25.83" y2="17.35" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
  </g>
</svg>

</span>
                                        <span class="sold-out-message hidden">
                      										Sold out
                    										</span>
                                            <div class="loading-overlay__spinner hidden">
                                                <svg aria-hidden="true" focusable="false" role="presentation"
                                                     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="10683816313144" /><input type="hidden" name="section-id" value="template--25629764616504__ax_featured_collections_rFyreh" /></form></product-form></div></div>
            </div>
        </a>
    </ax-product-card>


<link href="//www.lafumausa.com/cdn/shop/t/51/assets/component-rating.css?v=24573085263941240431725370615" rel="stylesheet" type="text/css" media="all" />


<ax-product-card>
        <a href="/products/set-of-2-deckchairs-lounger-maxi-transat-striped-airlon-indigo-tubing-indigo"
           class="product-miniature product-card-wrapper card-wrapper underline-links-hover">
            <div class="card
      card--card
       card--media
       color-background-1 gradient
      
      
      "
                 style="--ratio-percent: 100.0%;"
            >
                <div class="card__inner  ratio"
                     style="--ratio-percent: 100.0%;"><div class="card__media card__media_secondary">
                            <div class="media media--square media--transparent">
                                
																 
																	<img lazy-src="//www.lafumausa.com/cdn/shop/files/MAXITRANSATRAYURES_Indigo_1.jpg?v=1778076840&amp;width=550" alt="SET OF 2 DECKCHAIRS" lazy-srcset="//www.lafumausa.com/cdn/shop/files/MAXITRANSATRAYURES_Indigo_1.jpg?v=1778076840&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/MAXITRANSATRAYURES_Indigo_1.jpg?v=1778076840&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/MAXITRANSATRAYURES_Indigo_1.jpg?v=1778076840&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/MAXITRANSATRAYURES_Indigo_1.jpg?v=1778076840&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-primary">
																 
                                
<img lazy-src="//www.lafumausa.com/cdn/shop/files/LFM5393_A003_MAXI-TRANSAT-RAYURE_Indigo_2.jpg?v=1776355095&amp;width=550" alt="SET OF 2 DECKCHAIRS" lazy-srcset="//www.lafumausa.com/cdn/shop/files/LFM5393_A003_MAXI-TRANSAT-RAYURE_Indigo_2.jpg?v=1776355095&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/LFM5393_A003_MAXI-TRANSAT-RAYURE_Indigo_2.jpg?v=1776355095&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/LFM5393_A003_MAXI-TRANSAT-RAYURE_Indigo_2.jpg?v=1776355095&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/LFM5393_A003_MAXI-TRANSAT-RAYURE_Indigo_2.jpg?v=1776355095&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-secondary">
</div>
                        </div><div class="card__content">
                        <div class="card__badge bottom left">
                            
                                
                                
                            
                                
                                
                            
</div>
                    </div>
                </div>
                <div class="card__content">
                    <div class="card__information">
                        
                            <div class="card__heading h5" id="title-template--25629764616504__ax_featured_collections_rFyreh-10683817427256">
                                SET OF 2 DECKCHAIRS
                            </div>
                            <div class="card__product__text">Maxi Transat Airlon Indigo striped
                            </div>
                        
<span class="caption-large light"></span>
<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">
        $239.98
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Regular price</span>
          <s class="price-item price-item--regular">
            
              
            
          </s><span class="visually-hidden visually-hidden--inline">Sale price</span>
      <span class="price-item price-item--sale price-item--last">
        $239.98
      </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>
<div class="fake-variants"><div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9NQVhJVFJBTlNBVFJBWVVSRVNfSW5kaWdvXzEuanBnP3Y9MTc3ODA3Njg0MA==" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtc3RyaXBlZC1haXJsb24taW5kaWdvLXR1YmluZy1pbmRpZ28=" data-badge="" data-available="true" data-price="23998" data-compare-price="" data-money-price="$239.98" data-money-compare="" data-subtitle="Maxi Transat Airlon Indigo striped" class="fake-variant fake-variants__active">
				
				<img lazy-src="//www.lafumausa.com/cdn/shop/files/indigo-striped_small.png?v=7302879863266739431" alt="indigo-striped.png">
			</div>
		

<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9NQVhJVFJBTlNBVFJBWVVSRVNfTW9zc18xLmpwZz92PTE3NzgwNzY1Mjg=" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtc3RyaXBlZC1haXJsb24tbW9zcy10dWJpbmctbW9zcw==" data-badge="" data-available="true" data-price="23998" data-compare-price="" data-money-price="$239.98" data-money-compare="" data-subtitle="Maxi Transat Airlon Moss striped">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/moss-striped_small.png?v=446482300662613006" alt="moss-striped.png">
					</div>
				


<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9NQVhJVFJBTlNBVFJBWVVSRVNfTWllbF8xLmpwZz92PTE3NzgwNzY2Nzg=" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtc3RyaXBlZC1haXJsb24tbWllbC10dWJpbmctbWllbA==" data-badge="" data-available="true" data-price="23998" data-compare-price="" data-money-price="$239.98" data-money-compare="" data-subtitle="Maxi Transat Airlon Miel striped">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/miel-striped_small.png?v=1576242611408703135" alt="miel-striped.png">
					</div>
				

</div>
<div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--25629764616504__ax_featured_collections_rFyreh10683817427256" 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="52323832299832"
                                               disabled>
                                        <button
                                                id="quick-add-template--25629764616504__ax_featured_collections_rFyreh10683817427256-submit"
                                                type="submit"
                                                name="add"
                                                class="quick-add__submit btn btn-primary"
                                                aria-haspopup="dialog"
                                                aria-labelledby="quick-add-template--25629764616504__ax_featured_collections_rFyreh10683817427256-submit title-template--25629764616504__ax_featured_collections_rFyreh-10683817427256"
                                                aria-live="polite"
                                                data-sold-out-message="true"
                                                
                                        >
                    										<span class="quick-add__text">Add to bag
</span>
																				<span class="quick-add__icon hidden"><svg class="icon icon-cart" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 40">
  <g>
    <path d="M12.28,26.68A1.78,1.78,0,0,0,14,28H26a1.78,1.78,0,0,0,1.72-1.32l1.37-7.76A1.34,1.34,0,0,0,28,17.37l-.23,0H12.24a1.34,1.34,0,0,0-1.35,1.35,1.64,1.64,0,0,0,0,.23Z" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="14.17" y1="17.35" x2="17.29" y2="12" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="22.7" y1="12" x2="25.83" y2="17.35" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
  </g>
</svg>

</span>
                                        <span class="sold-out-message hidden">
                      										Sold out
                    										</span>
                                            <div class="loading-overlay__spinner hidden">
                                                <svg aria-hidden="true" focusable="false" role="presentation"
                                                     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="10683817427256" /><input type="hidden" name="section-id" value="template--25629764616504__ax_featured_collections_rFyreh" /></form></product-form></div></div>
            </div>
        </a>
    </ax-product-card>


<link href="//www.lafumausa.com/cdn/shop/t/51/assets/component-rating.css?v=24573085263941240431725370615" rel="stylesheet" type="text/css" media="all" />


<ax-product-card>
        <a href="/products/set-of-2-deckchairs-lounger-maxi-transat-colorblock-batyline-iso-miel-tubing-miel"
           class="product-miniature product-card-wrapper card-wrapper underline-links-hover">
            <div class="card
      card--card
       card--media
       color-background-1 gradient
      
      
      "
                 style="--ratio-percent: 100.0%;"
            >
                <div class="card__inner  ratio"
                     style="--ratio-percent: 100.0%;"><div class="card__media card__media_secondary">
                            <div class="media media--square media--transparent">
                                
																 
																	<img lazy-src="//www.lafumausa.com/cdn/shop/files/LFM5170_9987_MAXITRANSATCOLORBLOCK_Miel_1.jpg?v=1778514738&amp;width=550" alt="SET OF 2 DECKCHAIRS" lazy-srcset="//www.lafumausa.com/cdn/shop/files/LFM5170_9987_MAXITRANSATCOLORBLOCK_Miel_1.jpg?v=1778514738&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/LFM5170_9987_MAXITRANSATCOLORBLOCK_Miel_1.jpg?v=1778514738&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/LFM5170_9987_MAXITRANSATCOLORBLOCK_Miel_1.jpg?v=1778514738&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/LFM5170_9987_MAXITRANSATCOLORBLOCK_Miel_1.jpg?v=1778514738&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-primary">
																 
                                
<img lazy-src="//www.lafumausa.com/cdn/shop/files/LFM5170_9987_MAXI_TRANSAT_COLORBLOCK_Miel_2_1.jpg?v=1779210988&amp;width=550" alt="SET OF 2 DECKCHAIRS" lazy-srcset="//www.lafumausa.com/cdn/shop/files/LFM5170_9987_MAXI_TRANSAT_COLORBLOCK_Miel_2_1.jpg?v=1779210988&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/LFM5170_9987_MAXI_TRANSAT_COLORBLOCK_Miel_2_1.jpg?v=1779210988&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/LFM5170_9987_MAXI_TRANSAT_COLORBLOCK_Miel_2_1.jpg?v=1779210988&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/LFM5170_9987_MAXI_TRANSAT_COLORBLOCK_Miel_2_1.jpg?v=1779210988&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-secondary">
</div>
                        </div><div class="card__content">
                        <div class="card__badge bottom left">
                            
                                
                                
                            
                                
                                
                            
</div>
                    </div>
                </div>
                <div class="card__content">
                    <div class="card__information">
                        
                            <div class="card__heading h5" id="title-template--25629764616504__ax_featured_collections_rFyreh-10683802321208">
                                SET OF 2 DECKCHAIRS
                            </div>
                            <div class="card__product__text">Maxi Transat Batyline® Iso Miel miel
                            </div>
                        
<span class="caption-large light"></span>
<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">
        $219.98
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Regular price</span>
          <s class="price-item price-item--regular">
            
              
            
          </s><span class="visually-hidden visually-hidden--inline">Sale price</span>
      <span class="price-item price-item--sale price-item--last">
        $219.98
      </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>
<div class="fake-variants"><div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9MRk01MTcwXzk5ODdfTUFYSVRSQU5TQVRDT0xPUkJMT0NLX01pZWxfMS5qcGc/dj0xNzc4NTE0NzM4" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtY29sb3JibG9jay1iYXR5bGluZS1pc28tbWllbC10dWJpbmctbWllbA==" data-badge="" data-available="true" data-price="21998" data-compare-price="" data-money-price="$219.98" data-money-compare="" data-subtitle="Maxi Transat Batyline® Iso Miel miel" class="fake-variant fake-variants__active">
				
				<img lazy-src="//www.lafumausa.com/cdn/shop/files/miel-miel_small.png?v=16607422716499233338" alt="miel-miel.png">
			</div>
		

<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9CVU5ETEVfTEZNNTE3MF85OTQwLmpwZz92PTE3MjQ4NjAwMTE=" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtY29sb3JibG9jay1iYXR5bGluZS1pc28taW5kaWdvLXR1YmluZy1pbmRpZ28=" data-badge="" data-available="true" data-price="21998" data-compare-price="" data-money-price="$219.98" data-money-compare="" data-subtitle="Maxi Transat Batyline® Iso Indigo indigo">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/indigo-indigo_small.png?v=9004787350335673744" alt="indigo-indigo.png">
					</div>
				


<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9NQVhJVFJBTlNBVENPTE9SQkxPQ0tfQ2FueW9uXzEuanBnP3Y9MTc3ODA3NDg5Mg==" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtY29sb3JibG9jay1iYXR5bGluZS1pc28tY2FueW9uLXR1YmluZy1jYW55b24=" data-badge="" data-available="true" data-price="21998" data-compare-price="" data-money-price="$219.98" data-money-compare="" data-subtitle="Maxi Transat Batyline® Iso Canyon canyon">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/canyon-canyon_small.png?v=16978918801014132830" alt="canyon-canyon.png">
					</div>
				


<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9NQVhJVFJBTlNBVF9Nb3NzXzEuanBnP3Y9MTc3ODA3NTA4OA==" data-obfuscated-url="L3Byb2R1Y3RzL3NldC1vZi0yLWRlY2tjaGFpcnMtbG91bmdlci1tYXhpLXRyYW5zYXQtY29sb3JibG9jay1iYXR5bGluZS1pc28tbW9zcy10dWJpbmctbW9zcw==" data-badge="PHNwYW4gY2xhc3M9ImJhZGdlIGJhZGdlLS1ib3R0b20tbGVmdCBjb2xvci1pbnZlcnNlIj5Tb2xkIG91dDwvc3Bhbj4=" data-available="false" data-price="21998" data-compare-price="" data-money-price="$219.98" data-money-compare="" data-subtitle="Maxi Transat Batyline® Iso Moss moss">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/moss-moss_small.png?v=5813533047511080129" alt="moss-moss.png">
					</div>
				


<div class="fake-variants__more">+</div></div>
<div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--25629764616504__ax_featured_collections_rFyreh10683802321208" 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="52323732226360"
                                               disabled>
                                        <button
                                                id="quick-add-template--25629764616504__ax_featured_collections_rFyreh10683802321208-submit"
                                                type="submit"
                                                name="add"
                                                class="quick-add__submit btn btn-primary"
                                                aria-haspopup="dialog"
                                                aria-labelledby="quick-add-template--25629764616504__ax_featured_collections_rFyreh10683802321208-submit title-template--25629764616504__ax_featured_collections_rFyreh-10683802321208"
                                                aria-live="polite"
                                                data-sold-out-message="true"
                                                
                                        >
                    										<span class="quick-add__text">Add to bag
</span>
																				<span class="quick-add__icon hidden"><svg class="icon icon-cart" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 40">
  <g>
    <path d="M12.28,26.68A1.78,1.78,0,0,0,14,28H26a1.78,1.78,0,0,0,1.72-1.32l1.37-7.76A1.34,1.34,0,0,0,28,17.37l-.23,0H12.24a1.34,1.34,0,0,0-1.35,1.35,1.64,1.64,0,0,0,0,.23Z" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="14.17" y1="17.35" x2="17.29" y2="12" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="22.7" y1="12" x2="25.83" y2="17.35" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
  </g>
</svg>

</span>
                                        <span class="sold-out-message hidden">
                      										Sold out
                    										</span>
                                            <div class="loading-overlay__spinner hidden">
                                                <svg aria-hidden="true" focusable="false" role="presentation"
                                                     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="10683802321208" /><input type="hidden" name="section-id" value="template--25629764616504__ax_featured_collections_rFyreh" /></form></product-form></div></div>
            </div>
        </a>
    </ax-product-card>
View all


<link href="//www.lafumausa.com/cdn/shop/t/51/assets/component-rating.css?v=24573085263941240431725370615" rel="stylesheet" type="text/css" media="all" />


<ax-product-card>
        <a href="/products/folding-camping-chair-alu-cham-batyline-iso-ocean-2"
           class="product-miniature product-card-wrapper card-wrapper underline-links-hover">
            <div class="card
      card--card
       card--media
       color-background-1 gradient
      
      
      "
                 style="--ratio-percent: 100.0%;"
            >
                <div class="card__inner  ratio"
                     style="--ratio-percent: 100.0%;"><div class="card__media card__media_secondary">
                            <div class="media media--square media--transparent">
                                
																 
																	<img lazy-src="//www.lafumausa.com/cdn/shop/files/LFM5083_9871_ALU-CHAM_Ocean-II_1.jpg?v=1776355095&amp;width=550" alt="CAMPING ARMCHAIR" lazy-srcset="//www.lafumausa.com/cdn/shop/files/LFM5083_9871_ALU-CHAM_Ocean-II_1.jpg?v=1776355095&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/LFM5083_9871_ALU-CHAM_Ocean-II_1.jpg?v=1776355095&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/LFM5083_9871_ALU-CHAM_Ocean-II_1.jpg?v=1776355095&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/LFM5083_9871_ALU-CHAM_Ocean-II_1.jpg?v=1776355095&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-primary">
																 
                                
<img lazy-src="//www.lafumausa.com/cdn/shop/files/LFM5083_9871_ALU-CHAM_Ocean-II_2.jpg?v=1776355095&amp;width=550" alt="CAMPING ARMCHAIR" lazy-srcset="//www.lafumausa.com/cdn/shop/files/LFM5083_9871_ALU-CHAM_Ocean-II_2.jpg?v=1776355095&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/LFM5083_9871_ALU-CHAM_Ocean-II_2.jpg?v=1776355095&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/LFM5083_9871_ALU-CHAM_Ocean-II_2.jpg?v=1776355095&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/LFM5083_9871_ALU-CHAM_Ocean-II_2.jpg?v=1776355095&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-secondary">
</div>
                        </div><div class="card__content">
                        <div class="card__badge bottom left">
                            
                                
                                
                            
                                
                                
                            
</div>
                    </div>
                </div>
                <div class="card__content">
                    <div class="card__information">
                        
                            <div class="card__heading h5" id="title-template--25629764616504__ax_featured_collections_rFyreh-9440785498424">
                                CAMPING ARMCHAIR
                            </div>
                            <div class="card__product__text">Alu Cham Batyline® Iso Océan
                            </div>
                        
<span class="caption-large light"></span>
<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">
        $139.99
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Regular price</span>
          <s class="price-item price-item--regular">
            
              
            
          </s><span class="visually-hidden visually-hidden--inline">Sale price</span>
      <span class="price-item price-item--sale price-item--last">
        $139.99
      </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>
<div class="fake-variants"><div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9MRk01MDgzXzk4NzFfQUxVLUNIQU1fT2NlYW4tSUlfMS5qcGc/dj0xNzc2MzU1MDk1" data-obfuscated-url="L3Byb2R1Y3RzL2ZvbGRpbmctY2FtcGluZy1jaGFpci1hbHUtY2hhbS1iYXR5bGluZS1pc28tb2NlYW4tMg==" data-badge="" data-available="true" data-price="13999" data-compare-price="" data-money-price="$139.99" data-money-compare="" data-subtitle="Alu Cham Batyline® Iso Océan" class="fake-variant fake-variants__active">
				
				<img lazy-src="//www.lafumausa.com/cdn/shop/files/ocean_small.png?v=4121364727694464224" alt="ocean.png">
			</div>
		

<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9MRk01MDgzXzk4NjlfQUxVLUNIQU1fU2VpZ2xlLUlJXzEuanBnP3Y9MTc1OTE1OTA1NQ==" data-obfuscated-url="L3Byb2R1Y3RzL2ZvbGRpbmctY2FtcGluZy1jaGFpci1hbHUtY2hhbS1iYXR5bGluZS1pc28tc2VpZ2xl" data-badge="" data-available="true" data-price="13999" data-compare-price="" data-money-price="$139.99" data-money-compare="" data-subtitle="Alu Cham Batyline® Iso Seigle">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/seigle_small.png?v=15340529351016768052" alt="seigle.png">
					</div>
				


<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9MRk01MDgzXzk5MjdfQUxVLUNIQU1fTW9zc18xLmpwZz92PTE3NDgzNTY5NDQ=" data-obfuscated-url="L3Byb2R1Y3RzL2ZvbGRpbmctY2FtcGluZy1jaGFpci1hbHUtY2hhbS1iYXR5bGluZS1pc28tbW9zcw==" data-badge="" data-available="true" data-price="13999" data-compare-price="" data-money-price="$139.99" data-money-compare="" data-subtitle="Alu Cham Batyline® Iso Moss">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/moss_small.png?v=8183936021895677220" alt="moss.png">
					</div>
				

</div>
<div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--25629764616504__ax_featured_collections_rFyreh9440785498424" 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="48885607006520"
                                               disabled>
                                        <button
                                                id="quick-add-template--25629764616504__ax_featured_collections_rFyreh9440785498424-submit"
                                                type="submit"
                                                name="add"
                                                class="quick-add__submit btn btn-primary"
                                                aria-haspopup="dialog"
                                                aria-labelledby="quick-add-template--25629764616504__ax_featured_collections_rFyreh9440785498424-submit title-template--25629764616504__ax_featured_collections_rFyreh-9440785498424"
                                                aria-live="polite"
                                                data-sold-out-message="true"
                                                
                                        >
                    										<span class="quick-add__text">Add to bag
</span>
																				<span class="quick-add__icon hidden"><svg class="icon icon-cart" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 40">
  <g>
    <path d="M12.28,26.68A1.78,1.78,0,0,0,14,28H26a1.78,1.78,0,0,0,1.72-1.32l1.37-7.76A1.34,1.34,0,0,0,28,17.37l-.23,0H12.24a1.34,1.34,0,0,0-1.35,1.35,1.64,1.64,0,0,0,0,.23Z" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="14.17" y1="17.35" x2="17.29" y2="12" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="22.7" y1="12" x2="25.83" y2="17.35" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
  </g>
</svg>

</span>
                                        <span class="sold-out-message hidden">
                      										Sold out
                    										</span>
                                            <div class="loading-overlay__spinner hidden">
                                                <svg aria-hidden="true" focusable="false" role="presentation"
                                                     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="9440785498424" /><input type="hidden" name="section-id" value="template--25629764616504__ax_featured_collections_rFyreh" /></form></product-form></div></div>
            </div>
        </a>
    </ax-product-card>


<link href="//www.lafumausa.com/cdn/shop/t/51/assets/component-rating.css?v=24573085263941240431725370615" rel="stylesheet" type="text/css" media="all" />


<ax-product-card>
        <a href="/products/folding-camping-chair-chamelips-air-comfort-taupe"
           class="product-miniature product-card-wrapper card-wrapper underline-links-hover">
            <div class="card
      card--card
       card--media
       color-background-1 gradient
      
      
      "
                 style="--ratio-percent: 100.0%;"
            >
                <div class="card__inner  ratio"
                     style="--ratio-percent: 100.0%;"><div class="card__media card__media_secondary">
                            <div class="media media--square media--transparent">
                                
																 
																	<img lazy-src="//www.lafumausa.com/cdn/shop/products/LFM5084_6899_folding-camping-chair-chamelips-air-comfort-taupe.jpg?v=1679677909&amp;width=550" alt="CAMPING ARMCHAIR" lazy-srcset="//www.lafumausa.com/cdn/shop/products/LFM5084_6899_folding-camping-chair-chamelips-air-comfort-taupe.jpg?v=1679677909&amp;width=180 180w, //www.lafumausa.com/cdn/shop/products/LFM5084_6899_folding-camping-chair-chamelips-air-comfort-taupe.jpg?v=1679677909&amp;width=220 220w, //www.lafumausa.com/cdn/shop/products/LFM5084_6899_folding-camping-chair-chamelips-air-comfort-taupe.jpg?v=1679677909&amp;width=330 330w, //www.lafumausa.com/cdn/shop/products/LFM5084_6899_folding-camping-chair-chamelips-air-comfort-taupe.jpg?v=1679677909&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-primary">
																 
                                
<img lazy-src="//www.lafumausa.com/cdn/shop/products/LFM5084_6899_1_folding-camping-chair-chamelips-air-comfort-taupe.jpg?v=1679677909&amp;width=550" alt="CAMPING ARMCHAIR" lazy-srcset="//www.lafumausa.com/cdn/shop/products/LFM5084_6899_1_folding-camping-chair-chamelips-air-comfort-taupe.jpg?v=1679677909&amp;width=180 180w, //www.lafumausa.com/cdn/shop/products/LFM5084_6899_1_folding-camping-chair-chamelips-air-comfort-taupe.jpg?v=1679677909&amp;width=220 220w, //www.lafumausa.com/cdn/shop/products/LFM5084_6899_1_folding-camping-chair-chamelips-air-comfort-taupe.jpg?v=1679677909&amp;width=330 330w, //www.lafumausa.com/cdn/shop/products/LFM5084_6899_1_folding-camping-chair-chamelips-air-comfort-taupe.jpg?v=1679677909&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-secondary">
</div>
                        </div><div class="card__content">
                        <div class="card__badge bottom left">
                            
                                
                                
                            
                                
                                
                            
</div>
                    </div>
                </div>
                <div class="card__content">
                    <div class="card__information">
                        
                            <div class="card__heading h5" id="title-template--25629764616504__ax_featured_collections_rFyreh-8204763889976">
                                CAMPING ARMCHAIR
                            </div>
                            <div class="card__product__text">Alu Cham Air Comfort® Taupe
                            </div>
                        
<span class="caption-large light"></span>
<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">
        $199.99
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Regular price</span>
          <s class="price-item price-item--regular">
            
              
            
          </s><span class="visually-hidden visually-hidden--inline">Sale price</span>
      <span class="price-item price-item--sale price-item--last">
        $199.99
      </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>
<div class="fake-variants"><div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9wcm9kdWN0cy9MRk01MDg0XzY4OTlfZm9sZGluZy1jYW1waW5nLWNoYWlyLWNoYW1lbGlwcy1haXItY29tZm9ydC10YXVwZS5qcGc/dj0xNjc5Njc3OTA5" data-obfuscated-url="L3Byb2R1Y3RzL2ZvbGRpbmctY2FtcGluZy1jaGFpci1jaGFtZWxpcHMtYWlyLWNvbWZvcnQtdGF1cGU=" data-badge="" data-available="true" data-price="19999" data-compare-price="" data-money-price="$199.99" data-money-compare="" data-subtitle="Alu Cham Air Comfort® Taupe" class="fake-variant fake-variants__active">
				
				<img lazy-src="//www.lafumausa.com/cdn/shop/files/taupe_small.png?v=7456518624742160901" alt="taupe.png">
			</div>
		

<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9wcm9kdWN0cy9MRk01MDg0XzY1ODlfZm9sZGluZy1jYW1waW5nLWNoYWlyLWNoYW0tYWlyLWNvbWZvcnQtYWNpZXIuanBnP3Y9MTY3OTY3NzkwOQ==" data-obfuscated-url="L3Byb2R1Y3RzL2ZvbGRpbmctY2FtcGluZy1jaGFpci1jaGFtLWFpci1jb21mb3J0LWFjaWVy" data-badge="" data-available="true" data-price="19999" data-compare-price="" data-money-price="$199.99" data-money-compare="" data-subtitle="Alu Cham Air Comfort® Steel">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/steel_small.png?v=1810514183239462301" alt="steel.png">
					</div>
				

</div>
<div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--25629764616504__ax_featured_collections_rFyreh8204763889976" 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="44814904623416"
                                               disabled>
                                        <button
                                                id="quick-add-template--25629764616504__ax_featured_collections_rFyreh8204763889976-submit"
                                                type="submit"
                                                name="add"
                                                class="quick-add__submit btn btn-primary"
                                                aria-haspopup="dialog"
                                                aria-labelledby="quick-add-template--25629764616504__ax_featured_collections_rFyreh8204763889976-submit title-template--25629764616504__ax_featured_collections_rFyreh-8204763889976"
                                                aria-live="polite"
                                                data-sold-out-message="true"
                                                
                                        >
                    										<span class="quick-add__text">Add to bag
</span>
																				<span class="quick-add__icon hidden"><svg class="icon icon-cart" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 40">
  <g>
    <path d="M12.28,26.68A1.78,1.78,0,0,0,14,28H26a1.78,1.78,0,0,0,1.72-1.32l1.37-7.76A1.34,1.34,0,0,0,28,17.37l-.23,0H12.24a1.34,1.34,0,0,0-1.35,1.35,1.64,1.64,0,0,0,0,.23Z" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="14.17" y1="17.35" x2="17.29" y2="12" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="22.7" y1="12" x2="25.83" y2="17.35" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
  </g>
</svg>

</span>
                                        <span class="sold-out-message hidden">
                      										Sold out
                    										</span>
                                            <div class="loading-overlay__spinner hidden">
                                                <svg aria-hidden="true" focusable="false" role="presentation"
                                                     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="8204763889976" /><input type="hidden" name="section-id" value="template--25629764616504__ax_featured_collections_rFyreh" /></form></product-form></div></div>
            </div>
        </a>
    </ax-product-card>


<link href="//www.lafumausa.com/cdn/shop/t/51/assets/component-rating.css?v=24573085263941240431725370615" rel="stylesheet" type="text/css" media="all" />


<ax-product-card>
        <a href="/products/folding-camping-chair-alu-cham-xl-batyline-iso-moss"
           class="product-miniature product-card-wrapper card-wrapper underline-links-hover">
            <div class="card
      card--card
       card--media
       color-background-1 gradient
      
      
      "
                 style="--ratio-percent: 100.0%;"
            >
                <div class="card__inner  ratio"
                     style="--ratio-percent: 100.0%;"><div class="card__media card__media_secondary">
                            <div class="media media--square media--transparent">
                                
																 
																	<img lazy-src="//www.lafumausa.com/cdn/shop/files/LFM5085_9927_ALU-CHAM-XL_Moss_1.jpg?v=1742570082&amp;width=550" alt="CAMPING ARMCHAIR XL" lazy-srcset="//www.lafumausa.com/cdn/shop/files/LFM5085_9927_ALU-CHAM-XL_Moss_1.jpg?v=1742570082&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/LFM5085_9927_ALU-CHAM-XL_Moss_1.jpg?v=1742570082&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/LFM5085_9927_ALU-CHAM-XL_Moss_1.jpg?v=1742570082&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/LFM5085_9927_ALU-CHAM-XL_Moss_1.jpg?v=1742570082&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-primary">
																 
                                
<img lazy-src="//www.lafumausa.com/cdn/shop/files/LFM5085_9927_ALU-CHAM-XL_Moss_2.jpg?v=1742570085&amp;width=550" alt="CAMPING ARMCHAIR XL" lazy-srcset="//www.lafumausa.com/cdn/shop/files/LFM5085_9927_ALU-CHAM-XL_Moss_2.jpg?v=1742570085&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/LFM5085_9927_ALU-CHAM-XL_Moss_2.jpg?v=1742570085&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/LFM5085_9927_ALU-CHAM-XL_Moss_2.jpg?v=1742570085&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/LFM5085_9927_ALU-CHAM-XL_Moss_2.jpg?v=1742570085&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-secondary">
</div>
                        </div><div class="card__content">
                        <div class="card__badge bottom left">
                            
                                
                                
                            
                                
                                
                            
                                
                                    <span class="badge badge--bottom-left color-accent-1">XL</span>
                                
                                
                            
</div>
                    </div>
                </div>
                <div class="card__content">
                    <div class="card__information">
                        
                            <div class="card__heading h5" id="title-template--25629764616504__ax_featured_collections_rFyreh-9832077361464">
                                CAMPING ARMCHAIR XL
                            </div>
                            <div class="card__product__text">Alu Cham XL Batyline® Iso Moss
                            </div>
                        
<span class="caption-large light"></span>
<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">
        $165.00
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Regular price</span>
          <s class="price-item price-item--regular">
            
              
            
          </s><span class="visually-hidden visually-hidden--inline">Sale price</span>
      <span class="price-item price-item--sale price-item--last">
        $165.00
      </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>
<div class="fake-variants"><div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9MRk01MDg1Xzk5MjdfQUxVLUNIQU0tWExfTW9zc18xLmpwZz92PTE3NDI1NzAwODI=" data-obfuscated-url="L3Byb2R1Y3RzL2ZvbGRpbmctY2FtcGluZy1jaGFpci1hbHUtY2hhbS14bC1iYXR5bGluZS1pc28tbW9zcw==" data-badge="PHNwYW4gY2xhc3M9ImJhZGdlIGJhZGdlLS1ib3R0b20tbGVmdCBjb2xvci1hY2NlbnQtMSI+WEw8L3NwYW4+" data-available="true" data-price="16500" data-compare-price="" data-money-price="$165.00" data-money-compare="" data-subtitle="Alu Cham XL Batyline® Iso Moss" class="fake-variant fake-variants__active">
				
				<img lazy-src="//www.lafumausa.com/cdn/shop/files/moss_small.png?v=8183936021895677220" alt="moss.png">
			</div>
		

<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9MRk01MDg1XzM4NjUuanBnP3Y9MTcxMzg3ODUyNg==" data-obfuscated-url="L3Byb2R1Y3RzL2ZvbGRpbmctY2FtcGluZy1jaGFpci1hbHUtY2hhbS14bC1iYXR5bGluZS1pc28tb2NlYW4=" data-badge="PHNwYW4gY2xhc3M9ImJhZGdlIGJhZGdlLS1ib3R0b20tbGVmdCBjb2xvci1hY2NlbnQtMSI+WEw8L3NwYW4+PHNwYW4gY2xhc3M9ImJhZGdlIGJhZGdlLS1ib3R0b20tbGVmdCBjb2xvci1pbnZlcnNlIj5Tb2xkIG91dDwvc3Bhbj4=" data-available="false" data-price="16500" data-compare-price="" data-money-price="$165.00" data-money-compare="" data-subtitle="Alu Cham XL Batyline® Iso Océan">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/ocean_small.png?v=4121364727694464224" alt="ocean.png">
					</div>
				


<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9MRk01MDg1XzIxNzguanBnP3Y9MTcxMzg3ODU3Mw==" data-obfuscated-url="L3Byb2R1Y3RzL2ZvbGRpbmctY2FtcGluZy1jaGFpci1hbHUtY2hhbS14bC1iYXR5bGluZS1pc28tc2VpZ2xl" data-badge="PHNwYW4gY2xhc3M9ImJhZGdlIGJhZGdlLS1ib3R0b20tbGVmdCBjb2xvci1hY2NlbnQtMSI+WEw8L3NwYW4+" data-available="true" data-price="16500" data-compare-price="" data-money-price="$165.00" data-money-compare="" data-subtitle="Alu Cham XL Batyline® Iso Seigle">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/seigle_small.png?v=15340529351016768052" alt="seigle.png">
					</div>
				

</div>
<div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--25629764616504__ax_featured_collections_rFyreh9832077361464" 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="49893915099448"
                                               disabled>
                                        <button
                                                id="quick-add-template--25629764616504__ax_featured_collections_rFyreh9832077361464-submit"
                                                type="submit"
                                                name="add"
                                                class="quick-add__submit btn btn-primary"
                                                aria-haspopup="dialog"
                                                aria-labelledby="quick-add-template--25629764616504__ax_featured_collections_rFyreh9832077361464-submit title-template--25629764616504__ax_featured_collections_rFyreh-9832077361464"
                                                aria-live="polite"
                                                data-sold-out-message="true"
                                                
                                        >
                    										<span class="quick-add__text">Add to bag
</span>
																				<span class="quick-add__icon hidden"><svg class="icon icon-cart" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 40">
  <g>
    <path d="M12.28,26.68A1.78,1.78,0,0,0,14,28H26a1.78,1.78,0,0,0,1.72-1.32l1.37-7.76A1.34,1.34,0,0,0,28,17.37l-.23,0H12.24a1.34,1.34,0,0,0-1.35,1.35,1.64,1.64,0,0,0,0,.23Z" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="14.17" y1="17.35" x2="17.29" y2="12" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="22.7" y1="12" x2="25.83" y2="17.35" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
  </g>
</svg>

</span>
                                        <span class="sold-out-message hidden">
                      										Sold out
                    										</span>
                                            <div class="loading-overlay__spinner hidden">
                                                <svg aria-hidden="true" focusable="false" role="presentation"
                                                     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="9832077361464" /><input type="hidden" name="section-id" value="template--25629764616504__ax_featured_collections_rFyreh" /></form></product-form></div></div>
            </div>
        </a>
    </ax-product-card>


<link href="//www.lafumausa.com/cdn/shop/t/51/assets/component-rating.css?v=24573085263941240431725370615" rel="stylesheet" type="text/css" media="all" />


<ax-product-card>
        <a href="/products/design-chair-pop-up-batyline-iso-moss-tubing-titane"
           class="product-miniature product-card-wrapper card-wrapper underline-links-hover">
            <div class="card
      card--card
       card--media
       color-background-1 gradient
      
      
      "
                 style="--ratio-percent: 100.0%;"
            >
                <div class="card__inner  ratio"
                     style="--ratio-percent: 100.0%;"><div class="card__media card__media_secondary">
                            <div class="media media--square media--transparent">
                                
																 
																	<img lazy-src="//www.lafumausa.com/cdn/shop/files/LFM1837_8557_MAXI-POP-UP_Moss_1.jpg?v=1776355095&amp;width=550" alt="DESIGN CHAIR" lazy-srcset="//www.lafumausa.com/cdn/shop/files/LFM1837_8557_MAXI-POP-UP_Moss_1.jpg?v=1776355095&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/LFM1837_8557_MAXI-POP-UP_Moss_1.jpg?v=1776355095&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/LFM1837_8557_MAXI-POP-UP_Moss_1.jpg?v=1776355095&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/LFM1837_8557_MAXI-POP-UP_Moss_1.jpg?v=1776355095&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-primary">
																 
                                
<img lazy-src="//www.lafumausa.com/cdn/shop/files/LFM1837_8557_MAXI-POP-UP_Moss_2.jpg?v=1776355095&amp;width=550" alt="DESIGN CHAIR" lazy-srcset="//www.lafumausa.com/cdn/shop/files/LFM1837_8557_MAXI-POP-UP_Moss_2.jpg?v=1776355095&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/LFM1837_8557_MAXI-POP-UP_Moss_2.jpg?v=1776355095&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/LFM1837_8557_MAXI-POP-UP_Moss_2.jpg?v=1776355095&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/LFM1837_8557_MAXI-POP-UP_Moss_2.jpg?v=1776355095&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-secondary">
</div>
                        </div><div class="card__content">
                        <div class="card__badge bottom left">
                            
                                
                                
                            
                                
                                
                            
                                
                                
                            
                                
                                
                            

                                <span class="badge badge--bottom-left color-inverse">Sold out</span></div>
                    </div>
                </div>
                <div class="card__content">
                    <div class="card__information">
                        
                            <div class="card__heading h5" id="title-template--25629764616504__ax_featured_collections_rFyreh-8203983388984">
                                DESIGN CHAIR
                            </div>
                            <div class="card__product__text">Pop Up Batyline® Iso Moss
                            </div>
                        
<span class="caption-large light"></span>
<div class="price  price--sold-out ">
  <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">
        $129.99
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Regular price</span>
          <s class="price-item price-item--regular">
            
              
            
          </s><span class="visually-hidden visually-hidden--inline">Sale price</span>
      <span class="price-item price-item--sale price-item--last">
        $129.99
      </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>
<div class="fake-variants"><div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9MRk0xODM3Xzg1NTdfTUFYSS1QT1AtVVBfTW9zc18xLmpwZz92PTE3NzYzNTUwOTU=" data-obfuscated-url="L3Byb2R1Y3RzL2Rlc2lnbi1jaGFpci1wb3AtdXAtYmF0eWxpbmUtaXNvLW1vc3MtdHViaW5nLXRpdGFuZQ==" data-badge="PHNwYW4gY2xhc3M9ImJhZGdlIGJhZGdlLS1ib3R0b20tbGVmdCBjb2xvci1pbnZlcnNlIj5Tb2xkIG91dDwvc3Bhbj4=" data-available="false" data-price="12999" data-compare-price="" data-money-price="$129.99" data-money-compare="" data-subtitle="Pop Up Batyline® Iso Moss" class="fake-variant fake-variants__active">
				
				<img lazy-src="//www.lafumausa.com/cdn/shop/files/moss_small.png?v=8183936021895677220" alt="moss.png">
			</div>
		
</div>
<div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--25629764616504__ax_featured_collections_rFyreh8203983388984" 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="44813347848504"
                                               disabled>
                                        <button
                                                id="quick-add-template--25629764616504__ax_featured_collections_rFyreh8203983388984-submit"
                                                type="submit"
                                                name="add"
                                                class="quick-add__submit btn btn-primary"
                                                aria-haspopup="dialog"
                                                aria-labelledby="quick-add-template--25629764616504__ax_featured_collections_rFyreh8203983388984-submit title-template--25629764616504__ax_featured_collections_rFyreh-8203983388984"
                                                aria-live="polite"
                                                data-sold-out-message="true"
                                                disabled
                                        >
                    										<span class="quick-add__text">Sold out
</span>
																				<span class="quick-add__icon hidden"><svg class="icon icon-cart" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 40">
  <g>
    <path d="M12.28,26.68A1.78,1.78,0,0,0,14,28H26a1.78,1.78,0,0,0,1.72-1.32l1.37-7.76A1.34,1.34,0,0,0,28,17.37l-.23,0H12.24a1.34,1.34,0,0,0-1.35,1.35,1.64,1.64,0,0,0,0,.23Z" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="14.17" y1="17.35" x2="17.29" y2="12" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="22.7" y1="12" x2="25.83" y2="17.35" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
  </g>
</svg>

</span>
                                        <span class="sold-out-message hidden">
                      										Sold out
                    										</span>
                                            <div class="loading-overlay__spinner hidden">
                                                <svg aria-hidden="true" focusable="false" role="presentation"
                                                     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="8203983388984" /><input type="hidden" name="section-id" value="template--25629764616504__ax_featured_collections_rFyreh" /></form></product-form></div></div>
            </div>
        </a>
    </ax-product-card>


<link href="//www.lafumausa.com/cdn/shop/t/51/assets/component-rating.css?v=24573085263941240431725370615" rel="stylesheet" type="text/css" media="all" />


<ax-product-card>
        <a href="/products/folding-camping-chair-alu-cham-batyline-iso-moss"
           class="product-miniature product-card-wrapper card-wrapper underline-links-hover">
            <div class="card
      card--card
       card--media
       color-background-1 gradient
      
      
      "
                 style="--ratio-percent: 100.0%;"
            >
                <div class="card__inner  ratio"
                     style="--ratio-percent: 100.0%;"><div class="card__media card__media_secondary">
                            <div class="media media--square media--transparent">
                                
																 
																	<img lazy-src="//www.lafumausa.com/cdn/shop/files/LFM5083_9927_ALU-CHAM_Moss_1.jpg?v=1748356944&amp;width=550" alt="CAMPING ARMCHAIR" lazy-srcset="//www.lafumausa.com/cdn/shop/files/LFM5083_9927_ALU-CHAM_Moss_1.jpg?v=1748356944&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/LFM5083_9927_ALU-CHAM_Moss_1.jpg?v=1748356944&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/LFM5083_9927_ALU-CHAM_Moss_1.jpg?v=1748356944&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/LFM5083_9927_ALU-CHAM_Moss_1.jpg?v=1748356944&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-primary">
																 
                                
<img lazy-src="//www.lafumausa.com/cdn/shop/files/LFM5083_9927_ALU-CHAM_Moss_3.jpg?v=1748356944&amp;width=550" alt="CAMPING ARMCHAIR" lazy-srcset="//www.lafumausa.com/cdn/shop/files/LFM5083_9927_ALU-CHAM_Moss_3.jpg?v=1748356944&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/LFM5083_9927_ALU-CHAM_Moss_3.jpg?v=1748356944&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/LFM5083_9927_ALU-CHAM_Moss_3.jpg?v=1748356944&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/LFM5083_9927_ALU-CHAM_Moss_3.jpg?v=1748356944&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-secondary">
</div>
                        </div><div class="card__content">
                        <div class="card__badge bottom left">
                            
                                
                                
                            
                                
                                
                            
</div>
                    </div>
                </div>
                <div class="card__content">
                    <div class="card__information">
                        
                            <div class="card__heading h5" id="title-template--25629764616504__ax_featured_collections_rFyreh-9440785563960">
                                CAMPING ARMCHAIR
                            </div>
                            <div class="card__product__text">Alu Cham Batyline® Iso Moss
                            </div>
                        
<span class="caption-large light"></span>
<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">
        $139.99
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Regular price</span>
          <s class="price-item price-item--regular">
            
              
            
          </s><span class="visually-hidden visually-hidden--inline">Sale price</span>
      <span class="price-item price-item--sale price-item--last">
        $139.99
      </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>
<div class="fake-variants"><div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9MRk01MDgzXzk5MjdfQUxVLUNIQU1fTW9zc18xLmpwZz92PTE3NDgzNTY5NDQ=" data-obfuscated-url="L3Byb2R1Y3RzL2ZvbGRpbmctY2FtcGluZy1jaGFpci1hbHUtY2hhbS1iYXR5bGluZS1pc28tbW9zcw==" data-badge="" data-available="true" data-price="13999" data-compare-price="" data-money-price="$139.99" data-money-compare="" data-subtitle="Alu Cham Batyline® Iso Moss" class="fake-variant fake-variants__active">
				
				<img lazy-src="//www.lafumausa.com/cdn/shop/files/moss_small.png?v=8183936021895677220" alt="moss.png">
			</div>
		

<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9MRk01MDgzXzk4NzFfQUxVLUNIQU1fT2NlYW4tSUlfMS5qcGc/dj0xNzc2MzU1MDk1" data-obfuscated-url="L3Byb2R1Y3RzL2ZvbGRpbmctY2FtcGluZy1jaGFpci1hbHUtY2hhbS1iYXR5bGluZS1pc28tb2NlYW4tMg==" data-badge="" data-available="true" data-price="13999" data-compare-price="" data-money-price="$139.99" data-money-compare="" data-subtitle="Alu Cham Batyline® Iso Océan">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/ocean_small.png?v=4121364727694464224" alt="ocean.png">
					</div>
				


<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9MRk01MDgzXzk4NjlfQUxVLUNIQU1fU2VpZ2xlLUlJXzEuanBnP3Y9MTc1OTE1OTA1NQ==" data-obfuscated-url="L3Byb2R1Y3RzL2ZvbGRpbmctY2FtcGluZy1jaGFpci1hbHUtY2hhbS1iYXR5bGluZS1pc28tc2VpZ2xl" data-badge="" data-available="true" data-price="13999" data-compare-price="" data-money-price="$139.99" data-money-compare="" data-subtitle="Alu Cham Batyline® Iso Seigle">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/seigle_small.png?v=15340529351016768052" alt="seigle.png">
					</div>
				

</div>
<div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--25629764616504__ax_featured_collections_rFyreh9440785563960" 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="48885607072056"
                                               disabled>
                                        <button
                                                id="quick-add-template--25629764616504__ax_featured_collections_rFyreh9440785563960-submit"
                                                type="submit"
                                                name="add"
                                                class="quick-add__submit btn btn-primary"
                                                aria-haspopup="dialog"
                                                aria-labelledby="quick-add-template--25629764616504__ax_featured_collections_rFyreh9440785563960-submit title-template--25629764616504__ax_featured_collections_rFyreh-9440785563960"
                                                aria-live="polite"
                                                data-sold-out-message="true"
                                                
                                        >
                    										<span class="quick-add__text">Add to bag
</span>
																				<span class="quick-add__icon hidden"><svg class="icon icon-cart" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 40">
  <g>
    <path d="M12.28,26.68A1.78,1.78,0,0,0,14,28H26a1.78,1.78,0,0,0,1.72-1.32l1.37-7.76A1.34,1.34,0,0,0,28,17.37l-.23,0H12.24a1.34,1.34,0,0,0-1.35,1.35,1.64,1.64,0,0,0,0,.23Z" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="14.17" y1="17.35" x2="17.29" y2="12" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="22.7" y1="12" x2="25.83" y2="17.35" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
  </g>
</svg>

</span>
                                        <span class="sold-out-message hidden">
                      										Sold out
                    										</span>
                                            <div class="loading-overlay__spinner hidden">
                                                <svg aria-hidden="true" focusable="false" role="presentation"
                                                     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="9440785563960" /><input type="hidden" name="section-id" value="template--25629764616504__ax_featured_collections_rFyreh" /></form></product-form></div></div>
            </div>
        </a>
    </ax-product-card>


<link href="//www.lafumausa.com/cdn/shop/t/51/assets/component-rating.css?v=24573085263941240431725370615" rel="stylesheet" type="text/css" media="all" />


<ax-product-card>
        <a href="/products/folding-camping-chair-alu-cham-xl-batyline-iso-seigle"
           class="product-miniature product-card-wrapper card-wrapper underline-links-hover">
            <div class="card
      card--card
       card--media
       color-background-1 gradient
      
      
      "
                 style="--ratio-percent: 100.0%;"
            >
                <div class="card__inner  ratio"
                     style="--ratio-percent: 100.0%;"><div class="card__media card__media_secondary">
                            <div class="media media--square media--transparent">
                                
																 
																	<img lazy-src="//www.lafumausa.com/cdn/shop/files/LFM5085_2178.jpg?v=1713878573&amp;width=550" alt="CAMPING ARMCHAIR XL" lazy-srcset="//www.lafumausa.com/cdn/shop/files/LFM5085_2178.jpg?v=1713878573&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/LFM5085_2178.jpg?v=1713878573&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/LFM5085_2178.jpg?v=1713878573&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/LFM5085_2178.jpg?v=1713878573&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-primary">
																 
                                
<img lazy-src="//www.lafumausa.com/cdn/shop/files/LFM5085_2178_1.jpg?v=1713878573&amp;width=550" alt="CAMPING ARMCHAIR XL" lazy-srcset="//www.lafumausa.com/cdn/shop/files/LFM5085_2178_1.jpg?v=1713878573&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/LFM5085_2178_1.jpg?v=1713878573&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/LFM5085_2178_1.jpg?v=1713878573&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/LFM5085_2178_1.jpg?v=1713878573&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-secondary">
</div>
                        </div><div class="card__content">
                        <div class="card__badge bottom left">
                            
                                
                                
                            
                                
                                
                            
                                
                                    <span class="badge badge--bottom-left color-accent-1">XL</span>
                                
                                
                            
</div>
                    </div>
                </div>
                <div class="card__content">
                    <div class="card__information">
                        
                            <div class="card__heading h5" id="title-template--25629764616504__ax_featured_collections_rFyreh-8204763463992">
                                CAMPING ARMCHAIR XL
                            </div>
                            <div class="card__product__text">Alu Cham XL Batyline® Iso Seigle
                            </div>
                        
<span class="caption-large light"></span>
<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">
        $165.00
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Regular price</span>
          <s class="price-item price-item--regular">
            
              
            
          </s><span class="visually-hidden visually-hidden--inline">Sale price</span>
      <span class="price-item price-item--sale price-item--last">
        $165.00
      </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>
<div class="fake-variants"><div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9MRk01MDg1XzIxNzguanBnP3Y9MTcxMzg3ODU3Mw==" data-obfuscated-url="L3Byb2R1Y3RzL2ZvbGRpbmctY2FtcGluZy1jaGFpci1hbHUtY2hhbS14bC1iYXR5bGluZS1pc28tc2VpZ2xl" data-badge="PHNwYW4gY2xhc3M9ImJhZGdlIGJhZGdlLS1ib3R0b20tbGVmdCBjb2xvci1hY2NlbnQtMSI+WEw8L3NwYW4+" data-available="true" data-price="16500" data-compare-price="" data-money-price="$165.00" data-money-compare="" data-subtitle="Alu Cham XL Batyline® Iso Seigle" class="fake-variant fake-variants__active">
				
				<img lazy-src="//www.lafumausa.com/cdn/shop/files/seigle_small.png?v=15340529351016768052" alt="seigle.png">
			</div>
		

<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9MRk01MDg1XzM4NjUuanBnP3Y9MTcxMzg3ODUyNg==" data-obfuscated-url="L3Byb2R1Y3RzL2ZvbGRpbmctY2FtcGluZy1jaGFpci1hbHUtY2hhbS14bC1iYXR5bGluZS1pc28tb2NlYW4=" data-badge="PHNwYW4gY2xhc3M9ImJhZGdlIGJhZGdlLS1ib3R0b20tbGVmdCBjb2xvci1hY2NlbnQtMSI+WEw8L3NwYW4+PHNwYW4gY2xhc3M9ImJhZGdlIGJhZGdlLS1ib3R0b20tbGVmdCBjb2xvci1pbnZlcnNlIj5Tb2xkIG91dDwvc3Bhbj4=" data-available="false" data-price="16500" data-compare-price="" data-money-price="$165.00" data-money-compare="" data-subtitle="Alu Cham XL Batyline® Iso Océan">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/ocean_small.png?v=4121364727694464224" alt="ocean.png">
					</div>
				


<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9MRk01MDg1Xzk5MjdfQUxVLUNIQU0tWExfTW9zc18xLmpwZz92PTE3NDI1NzAwODI=" data-obfuscated-url="L3Byb2R1Y3RzL2ZvbGRpbmctY2FtcGluZy1jaGFpci1hbHUtY2hhbS14bC1iYXR5bGluZS1pc28tbW9zcw==" data-badge="PHNwYW4gY2xhc3M9ImJhZGdlIGJhZGdlLS1ib3R0b20tbGVmdCBjb2xvci1hY2NlbnQtMSI+WEw8L3NwYW4+" data-available="true" data-price="16500" data-compare-price="" data-money-price="$165.00" data-money-compare="" data-subtitle="Alu Cham XL Batyline® Iso Moss">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/moss_small.png?v=8183936021895677220" alt="moss.png">
					</div>
				

</div>
<div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--25629764616504__ax_featured_collections_rFyreh8204763463992" 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="44814904197432"
                                               disabled>
                                        <button
                                                id="quick-add-template--25629764616504__ax_featured_collections_rFyreh8204763463992-submit"
                                                type="submit"
                                                name="add"
                                                class="quick-add__submit btn btn-primary"
                                                aria-haspopup="dialog"
                                                aria-labelledby="quick-add-template--25629764616504__ax_featured_collections_rFyreh8204763463992-submit title-template--25629764616504__ax_featured_collections_rFyreh-8204763463992"
                                                aria-live="polite"
                                                data-sold-out-message="true"
                                                
                                        >
                    										<span class="quick-add__text">Add to bag
</span>
																				<span class="quick-add__icon hidden"><svg class="icon icon-cart" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 40">
  <g>
    <path d="M12.28,26.68A1.78,1.78,0,0,0,14,28H26a1.78,1.78,0,0,0,1.72-1.32l1.37-7.76A1.34,1.34,0,0,0,28,17.37l-.23,0H12.24a1.34,1.34,0,0,0-1.35,1.35,1.64,1.64,0,0,0,0,.23Z" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="14.17" y1="17.35" x2="17.29" y2="12" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="22.7" y1="12" x2="25.83" y2="17.35" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
  </g>
</svg>

</span>
                                        <span class="sold-out-message hidden">
                      										Sold out
                    										</span>
                                            <div class="loading-overlay__spinner hidden">
                                                <svg aria-hidden="true" focusable="false" role="presentation"
                                                     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="8204763463992" /><input type="hidden" name="section-id" value="template--25629764616504__ax_featured_collections_rFyreh" /></form></product-form></div></div>
            </div>
        </a>
    </ax-product-card>


<link href="//www.lafumausa.com/cdn/shop/t/51/assets/component-rating.css?v=24573085263941240431725370615" rel="stylesheet" type="text/css" media="all" />


<ax-product-card>
        <a href="/products/folding-camping-chair-alu-cham-batyline-iso-seigle"
           class="product-miniature product-card-wrapper card-wrapper underline-links-hover">
            <div class="card
      card--card
       card--media
       color-background-1 gradient
      
      
      "
                 style="--ratio-percent: 100.0%;"
            >
                <div class="card__inner  ratio"
                     style="--ratio-percent: 100.0%;"><div class="card__media card__media_secondary">
                            <div class="media media--square media--transparent">
                                
																 
																	<img lazy-src="//www.lafumausa.com/cdn/shop/files/LFM5083_9869_ALU-CHAM_Seigle-II_1.jpg?v=1759159055&amp;width=550" alt="CAMPING ARMCHAIR" lazy-srcset="//www.lafumausa.com/cdn/shop/files/LFM5083_9869_ALU-CHAM_Seigle-II_1.jpg?v=1759159055&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/LFM5083_9869_ALU-CHAM_Seigle-II_1.jpg?v=1759159055&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/LFM5083_9869_ALU-CHAM_Seigle-II_1.jpg?v=1759159055&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/LFM5083_9869_ALU-CHAM_Seigle-II_1.jpg?v=1759159055&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-primary">
																 
                                
<img lazy-src="//www.lafumausa.com/cdn/shop/files/LFM5083_9869_ALU-CHAM_Seigle-II_2.jpg?v=1759159055&amp;width=550" alt="CAMPING ARMCHAIR" lazy-srcset="//www.lafumausa.com/cdn/shop/files/LFM5083_9869_ALU-CHAM_Seigle-II_2.jpg?v=1759159055&amp;width=180 180w, //www.lafumausa.com/cdn/shop/files/LFM5083_9869_ALU-CHAM_Seigle-II_2.jpg?v=1759159055&amp;width=220 220w, //www.lafumausa.com/cdn/shop/files/LFM5083_9869_ALU-CHAM_Seigle-II_2.jpg?v=1759159055&amp;width=330 330w, //www.lafumausa.com/cdn/shop/files/LFM5083_9869_ALU-CHAM_Seigle-II_2.jpg?v=1759159055&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-secondary">
</div>
                        </div><div class="card__content">
                        <div class="card__badge bottom left">
                            
                                
                                
                            
                                
                                
                            
</div>
                    </div>
                </div>
                <div class="card__content">
                    <div class="card__information">
                        
                            <div class="card__heading h5" id="title-template--25629764616504__ax_featured_collections_rFyreh-9440785531192">
                                CAMPING ARMCHAIR
                            </div>
                            <div class="card__product__text">Alu Cham Batyline® Iso Seigle
                            </div>
                        
<span class="caption-large light"></span>
<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">
        $139.99
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Regular price</span>
          <s class="price-item price-item--regular">
            
              
            
          </s><span class="visually-hidden visually-hidden--inline">Sale price</span>
      <span class="price-item price-item--sale price-item--last">
        $139.99
      </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>
<div class="fake-variants"><div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9MRk01MDgzXzk4NjlfQUxVLUNIQU1fU2VpZ2xlLUlJXzEuanBnP3Y9MTc1OTE1OTA1NQ==" data-obfuscated-url="L3Byb2R1Y3RzL2ZvbGRpbmctY2FtcGluZy1jaGFpci1hbHUtY2hhbS1iYXR5bGluZS1pc28tc2VpZ2xl" data-badge="" data-available="true" data-price="13999" data-compare-price="" data-money-price="$139.99" data-money-compare="" data-subtitle="Alu Cham Batyline® Iso Seigle" class="fake-variant fake-variants__active">
				
				<img lazy-src="//www.lafumausa.com/cdn/shop/files/seigle_small.png?v=15340529351016768052" alt="seigle.png">
			</div>
		

<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9MRk01MDgzXzk4NzFfQUxVLUNIQU1fT2NlYW4tSUlfMS5qcGc/dj0xNzc2MzU1MDk1" data-obfuscated-url="L3Byb2R1Y3RzL2ZvbGRpbmctY2FtcGluZy1jaGFpci1hbHUtY2hhbS1iYXR5bGluZS1pc28tb2NlYW4tMg==" data-badge="" data-available="true" data-price="13999" data-compare-price="" data-money-price="$139.99" data-money-compare="" data-subtitle="Alu Cham Batyline® Iso Océan">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/ocean_small.png?v=4121364727694464224" alt="ocean.png">
					</div>
				


<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9maWxlcy9MRk01MDgzXzk5MjdfQUxVLUNIQU1fTW9zc18xLmpwZz92PTE3NDgzNTY5NDQ=" data-obfuscated-url="L3Byb2R1Y3RzL2ZvbGRpbmctY2FtcGluZy1jaGFpci1hbHUtY2hhbS1iYXR5bGluZS1pc28tbW9zcw==" data-badge="" data-available="true" data-price="13999" data-compare-price="" data-money-price="$139.99" data-money-compare="" data-subtitle="Alu Cham Batyline® Iso Moss">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/moss_small.png?v=8183936021895677220" alt="moss.png">
					</div>
				

</div>
<div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--25629764616504__ax_featured_collections_rFyreh9440785531192" 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="48885606973752"
                                               disabled>
                                        <button
                                                id="quick-add-template--25629764616504__ax_featured_collections_rFyreh9440785531192-submit"
                                                type="submit"
                                                name="add"
                                                class="quick-add__submit btn btn-primary"
                                                aria-haspopup="dialog"
                                                aria-labelledby="quick-add-template--25629764616504__ax_featured_collections_rFyreh9440785531192-submit title-template--25629764616504__ax_featured_collections_rFyreh-9440785531192"
                                                aria-live="polite"
                                                data-sold-out-message="true"
                                                
                                        >
                    										<span class="quick-add__text">Add to bag
</span>
																				<span class="quick-add__icon hidden"><svg class="icon icon-cart" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 40">
  <g>
    <path d="M12.28,26.68A1.78,1.78,0,0,0,14,28H26a1.78,1.78,0,0,0,1.72-1.32l1.37-7.76A1.34,1.34,0,0,0,28,17.37l-.23,0H12.24a1.34,1.34,0,0,0-1.35,1.35,1.64,1.64,0,0,0,0,.23Z" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="14.17" y1="17.35" x2="17.29" y2="12" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="22.7" y1="12" x2="25.83" y2="17.35" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
  </g>
</svg>

</span>
                                        <span class="sold-out-message hidden">
                      										Sold out
                    										</span>
                                            <div class="loading-overlay__spinner hidden">
                                                <svg aria-hidden="true" focusable="false" role="presentation"
                                                     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="9440785531192" /><input type="hidden" name="section-id" value="template--25629764616504__ax_featured_collections_rFyreh" /></form></product-form></div></div>
            </div>
        </a>
    </ax-product-card>


<link href="//www.lafumausa.com/cdn/shop/t/51/assets/component-rating.css?v=24573085263941240431725370615" rel="stylesheet" type="text/css" media="all" />


<ax-product-card>
        <a href="/products/folding-camping-chair-cham-air-comfort-acier"
           class="product-miniature product-card-wrapper card-wrapper underline-links-hover">
            <div class="card
      card--card
       card--media
       color-background-1 gradient
      
      
      "
                 style="--ratio-percent: 100.0%;"
            >
                <div class="card__inner  ratio"
                     style="--ratio-percent: 100.0%;"><div class="card__media card__media_secondary">
                            <div class="media media--square media--transparent">
                                
																 
																	<img lazy-src="//www.lafumausa.com/cdn/shop/products/LFM5084_6589_folding-camping-chair-cham-air-comfort-acier.jpg?v=1679677909&amp;width=550" alt="CAMPING ARMCHAIR" lazy-srcset="//www.lafumausa.com/cdn/shop/products/LFM5084_6589_folding-camping-chair-cham-air-comfort-acier.jpg?v=1679677909&amp;width=180 180w, //www.lafumausa.com/cdn/shop/products/LFM5084_6589_folding-camping-chair-cham-air-comfort-acier.jpg?v=1679677909&amp;width=220 220w, //www.lafumausa.com/cdn/shop/products/LFM5084_6589_folding-camping-chair-cham-air-comfort-acier.jpg?v=1679677909&amp;width=330 330w, //www.lafumausa.com/cdn/shop/products/LFM5084_6589_folding-camping-chair-cham-air-comfort-acier.jpg?v=1679677909&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-primary">
																 
                                
<img lazy-src="//www.lafumausa.com/cdn/shop/products/LFM5084_6589_1_folding-camping-chair-cham-air-comfort-acier.jpg?v=1679677909&amp;width=550" alt="CAMPING ARMCHAIR" lazy-srcset="//www.lafumausa.com/cdn/shop/products/LFM5084_6589_1_folding-camping-chair-cham-air-comfort-acier.jpg?v=1679677909&amp;width=180 180w, //www.lafumausa.com/cdn/shop/products/LFM5084_6589_1_folding-camping-chair-cham-air-comfort-acier.jpg?v=1679677909&amp;width=220 220w, //www.lafumausa.com/cdn/shop/products/LFM5084_6589_1_folding-camping-chair-cham-air-comfort-acier.jpg?v=1679677909&amp;width=330 330w, //www.lafumausa.com/cdn/shop/products/LFM5084_6589_1_folding-camping-chair-cham-air-comfort-acier.jpg?v=1679677909&amp;width=400 400w" width="550" height="550" loading="lazy" format="pjpg" class="motion-reduce image-secondary">
</div>
                        </div><div class="card__content">
                        <div class="card__badge bottom left">
                            
                                
                                
                            
                                
                                
                            
</div>
                    </div>
                </div>
                <div class="card__content">
                    <div class="card__information">
                        
                            <div class="card__heading h5" id="title-template--25629764616504__ax_featured_collections_rFyreh-8204763627832">
                                CAMPING ARMCHAIR
                            </div>
                            <div class="card__product__text">Alu Cham Air Comfort® Steel
                            </div>
                        
<span class="caption-large light"></span>
<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">
        $199.99
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Regular price</span>
          <s class="price-item price-item--regular">
            
              
            
          </s><span class="visually-hidden visually-hidden--inline">Sale price</span>
      <span class="price-item price-item--sale price-item--last">
        $199.99
      </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>
<div class="fake-variants"><div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9wcm9kdWN0cy9MRk01MDg0XzY1ODlfZm9sZGluZy1jYW1waW5nLWNoYWlyLWNoYW0tYWlyLWNvbWZvcnQtYWNpZXIuanBnP3Y9MTY3OTY3NzkwOQ==" data-obfuscated-url="L3Byb2R1Y3RzL2ZvbGRpbmctY2FtcGluZy1jaGFpci1jaGFtLWFpci1jb21mb3J0LWFjaWVy" data-badge="" data-available="true" data-price="19999" data-compare-price="" data-money-price="$199.99" data-money-compare="" data-subtitle="Alu Cham Air Comfort® Steel" class="fake-variant fake-variants__active">
				
				<img lazy-src="//www.lafumausa.com/cdn/shop/files/steel_small.png?v=1810514183239462301" alt="steel.png">
			</div>
		

<div data-product-image="Ly93d3cubGFmdW1hdXNhLmNvbS9jZG4vc2hvcC9wcm9kdWN0cy9MRk01MDg0XzY4OTlfZm9sZGluZy1jYW1waW5nLWNoYWlyLWNoYW1lbGlwcy1haXItY29tZm9ydC10YXVwZS5qcGc/dj0xNjc5Njc3OTA5" data-obfuscated-url="L3Byb2R1Y3RzL2ZvbGRpbmctY2FtcGluZy1jaGFpci1jaGFtZWxpcHMtYWlyLWNvbWZvcnQtdGF1cGU=" data-badge="" data-available="true" data-price="19999" data-compare-price="" data-money-price="$199.99" data-money-compare="" data-subtitle="Alu Cham Air Comfort® Taupe">
						
						<img lazy-src="//www.lafumausa.com/cdn/shop/files/taupe_small.png?v=7456518624742160901" alt="taupe.png">
					</div>
				

</div>
<div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--25629764616504__ax_featured_collections_rFyreh8204763627832" 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="44814904361272"
                                               disabled>
                                        <button
                                                id="quick-add-template--25629764616504__ax_featured_collections_rFyreh8204763627832-submit"
                                                type="submit"
                                                name="add"
                                                class="quick-add__submit btn btn-primary"
                                                aria-haspopup="dialog"
                                                aria-labelledby="quick-add-template--25629764616504__ax_featured_collections_rFyreh8204763627832-submit title-template--25629764616504__ax_featured_collections_rFyreh-8204763627832"
                                                aria-live="polite"
                                                data-sold-out-message="true"
                                                
                                        >
                    										<span class="quick-add__text">Add to bag
</span>
																				<span class="quick-add__icon hidden"><svg class="icon icon-cart" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 40">
  <g>
    <path d="M12.28,26.68A1.78,1.78,0,0,0,14,28H26a1.78,1.78,0,0,0,1.72-1.32l1.37-7.76A1.34,1.34,0,0,0,28,17.37l-.23,0H12.24a1.34,1.34,0,0,0-1.35,1.35,1.64,1.64,0,0,0,0,.23Z" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="14.17" y1="17.35" x2="17.29" y2="12" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
    <line x1="22.7" y1="12" x2="25.83" y2="17.35" fill="none" stroke="#000" stroke-linecap="round" stroke-linejoin="round"/>
  </g>
</svg>

</span>
                                        <span class="sold-out-message hidden">
                      										Sold out
                    										</span>
                                            <div class="loading-overlay__spinner hidden">
                                                <svg aria-hidden="true" focusable="false" role="presentation"
                                                     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="8204763627832" /><input type="hidden" name="section-id" value="template--25629764616504__ax_featured_collections_rFyreh" /></form></product-form></div></div>
            </div>
        </a>
    </ax-product-card>
View all
Discover our other universes
Relax image
Relax
Pool image
Pool
Camping image
Camping
Dining image
Dining
Lounge image
Lounge