Discover our New Collection
Promotions
Bed 140 cm
Bed 160 cm
Space-saving furniture
Length 154 cm - Sleeping area 120 x 190 cm - Double slatted base
Braderie
Length 154 cm - Sleeping area 120 x 190 cm - Double slatted base
+ 7 colors
Regular price
1 099 €
Sale price
1 099 €
Regular price
2 198,00 €
Unit price
/
per
Braderie
Length 178 cm - Sleeping area 140 x 190 cm
Braderie
Length 178 cm - Sleeping area 140 x 190 cm
Regular price
1 249 €
Sale price
1 249 €
Regular price
2 081,00 €
Unit price
/
per
Braderie
Length 150 cm - Bed 120 x 190 cm - Double slatted base
Braderie
Length 150 cm - Bed 120 x 190 cm - Double slatted base
+ 6 colors
Regular price
1 099 €
Sale price
1 099 €
Regular price
2 198,00 €
Unit price
/
per
Braderie
Length 202 cm - Sleeping area 140 x 190 cm - Double slatted base
Braderie
Length 202 cm - Sleeping area 140 x 190 cm - Double slatted base
Regular price
1 599 €
Sale price
1 599 €
Regular price
2 665,00 €
Unit price
/
per
Braderie
Length 188 cm - Sleeping area 140 x 190 cm - Double slatted base
Braderie
Length 188 cm - Sleeping area 140 x 190 cm - Double slatted base
+ 7 colors
Regular price
1 229 €
Sale price
1 229 €
Regular price
2 458,00 €
Unit price
/
per
Braderie
Length 170 cm - Bed 140 x 190 cm - Double slatted base
Braderie
Length 170 cm - Bed 140 x 190 cm - Double slatted base
+ 6 colors
Regular price
1 199 €
Sale price
1 199 €
Regular price
2 398,00 €
Unit price
/
per
Braderie
Length 190 cm - Bed 160 x 190 cm - Double slatted base
Braderie
Length 190 cm - Bed 160 x 190 cm - Double slatted base
+ 6 colors
Regular price
1 399 €
Sale price
1 399 €
Regular price
2 798,00 €
Unit price
/
per
Braderie
Length 160 cm - Sleeping area 120 x 190 cm - Double slatted base
Braderie
Length 160 cm - Sleeping area 120 x 190 cm - Double slatted base
+ 7 colors
Regular price
1 129 €
Sale price
1 129 €
Regular price
2 258,00 €
Unit price
/
per
Braderie
Length 180 cm - Sleeping area 140 x 190 cm - Double slatted base
Braderie
Length 180 cm - Sleeping area 140 x 190 cm - Double slatted base
+ 7 colors
Regular price
1 229 €
Sale price
1 229 €
Regular price
2 458,00 €
Unit price
/
per
Braderie
Length 200 cm - Bed 160 x 190 cm - Double slatted base
Braderie
Length 200 cm - Bed 160 x 190 cm - Double slatted base
+ 7 colors
Regular price
1 329 €
Sale price
1 329 €
Regular price
2 658,00 €
Unit price
/
per
Braderie


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/IBIZA_ECRU_2.jpg?v=1768295635&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_ECRU_2.jpg?v=1768295635&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_ECRU_2.jpg?v=1768295635&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_ECRU_2.jpg?v=1768295635&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_ECRU_2.jpg?v=1768295635&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_ECRU_2.jpg?v=1768295635&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_ECRU_2.jpg?v=1768295635 3120w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/IBIZA_ECRU_2.jpg?v=1768295635&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Ecru"
								class="motion-reduce"
								
								width="3120"
								height="1600"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/IBIZA_ECRU_1.jpg?v=1768295635&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_ECRU_1.jpg?v=1768295635&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_ECRU_1.jpg?v=1768295635&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_ECRU_1.jpg?v=1768295635&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_ECRU_1.jpg?v=1768295635&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_ECRU_1.jpg?v=1768295635&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_ECRU_1.jpg?v=1768295635 3120w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/IBIZA_ECRU_1.jpg?v=1768295635&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="#Ecru convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="3120"
									height="1600"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/ibiza-canape-convertible-3-places-lin"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-15387752300924"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-15387752300924 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-15387752300924"
								>
									IBIZA - 3-seater sofa bed - Linen
								</a>
							</div>
						
						<p class="card__description">Length 185 cm - Sleeping area 140 x 190 cm</p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="15387752300924"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-15387752300924"
							
						>
							<a
								href="/en/products/ibiza-canape-convertible-3-places-lin"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-15387752300924"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-15387752300924 Badge-template--26281868263804__ax_featured_collections_hdNrga-15387752300924"
							>
								
									IBIZA - 3-seater sofa bed - Linen
								
							</a> 
						</div>
						
							<p class="card__description">
								
									Length 185 cm - Sleeping area 140 x 190 cm
								
							</p>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="15387752300924"></div>
					</div>

					
						<div class="card__color">
							
								
<div
										class="card__color-item card__color-item--active"
										style="background-color: #000"
										data-url="/en/products/ibiza-canape-convertible-3-places-lin?variant=55459647488380"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/IBIZA_BEIGE_2.jpg?v=1750335079&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #e2d7cf"
										data-url="/en/products/ibiza-canape-convertible-3-places-lin?variant=55459647553916"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/IBIZA_ECRU_2.jpg?v=1768295635&width=675"
									>
									</div>
								
							
							
							
								
							
						</div>
					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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">
					1 899 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        1 899 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								3 798,00 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-50%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/MouginsLegacy161_4f587a54-8e33-444f-a7bb-6787664c07c1.jpg?v=1771344102&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/MouginsLegacy161_4f587a54-8e33-444f-a7bb-6787664c07c1.jpg?v=1771344102&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/MouginsLegacy161_4f587a54-8e33-444f-a7bb-6787664c07c1.jpg?v=1771344102&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/MouginsLegacy161_4f587a54-8e33-444f-a7bb-6787664c07c1.jpg?v=1771344102&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/MouginsLegacy161_4f587a54-8e33-444f-a7bb-6787664c07c1.jpg?v=1771344102&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/MouginsLegacy161_4f587a54-8e33-444f-a7bb-6787664c07c1.jpg?v=1771344102&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/MouginsLegacy161_4f587a54-8e33-444f-a7bb-6787664c07c1.jpg?v=1771344102 3955w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/MouginsLegacy161_4f587a54-8e33-444f-a7bb-6787664c07c1.jpg?v=1771344102&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Gris clair"
								class="motion-reduce"
								
								width="3955"
								height="2066"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/MouginesNoChair.jpg?v=1775123117&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/MouginesNoChair.jpg?v=1775123117&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/MouginesNoChair.jpg?v=1775123117&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/MouginesNoChair.jpg?v=1775123117&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/MouginesNoChair.jpg?v=1775123117&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/MouginesNoChair.jpg?v=1775123117&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/MouginesNoChair.jpg?v=1775123117 3120w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/MouginesNoChair.jpg?v=1775123117&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="MOUGINS 3-seater convertible sofa - Velvet - Bed 140 x 190 cm - Width 200 cm  convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="3120"
									height="1612"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/mougins-canape-convertible-3-places-velours"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-14938372866428"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-14938372866428 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-14938372866428"
								>
									MOUGINS 3-seater convertible sofa - Velvet - Bed 140 x 190 cm - Width 200 cm 
								</a>
							</div>
						
						<p class="card__description">Length 208 cm - Sleeping area 140 x 190 cm - Double slatted bed base</p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="14938372866428"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
							<div class="card__badge">
								<span
									id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-14938372866428"
									class="badge badge--bottom-left"
									style="background-color: #92b793; color: #ffffff;"
								>
									Top ventes
								</span>
							</div>
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-14938372866428"
							
						>
							<a
								href="/en/products/mougins-canape-convertible-3-places-velours"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-14938372866428"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-14938372866428 Badge-template--26281868263804__ax_featured_collections_hdNrga-14938372866428"
							>
								
									MOUGINS 3-seater convertible sofa - Velvet - Bed 140 x 190 cm - Width 200 cm 
								
							</a> 
						</div>
						
							<p class="card__description">
								
									Length 208 cm - Sleeping area 140 x 190 cm - Double slatted bed base
								
							</p>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="14938372866428"></div>
					</div>

					
						<div class="card__color">
							
								
<div
										class="card__color-item card__color-item--active"
										style="background-color: #888282"
										data-url="/en/products/mougins-canape-convertible-3-places-velours?variant=54859956126076"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/MouginsLegacy161_4f587a54-8e33-444f-a7bb-6787664c07c1.jpg?v=1771344102&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #e2d7cf"
										data-url="/en/products/mougins-canape-convertible-3-places-velours?variant=54859956093308"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/MouginsLegacy011.jpg?v=1775123147&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #978272
 aqua green"
										data-url="/en/products/mougins-canape-convertible-3-places-velours?variant=54890560094588"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/MouginsLegacy031_53aeb365-0804-453a-a224-a990c6a2340d.jpg?v=1775123147&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #000"
										data-url="/en/products/mougins-canape-convertible-3-places-velours?variant=55016237793660"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/MouginsLegacy11_3_2e065bb1-7bce-4a3a-a5bf-753a85190f02.jpg?v=1775123147&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #355000
 bluish grey"
										data-url="/en/products/mougins-canape-convertible-3-places-velours?variant=55407009563004"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Mougins_Legacy_10_KAKI_2.jpg?v=1771344102&width=675"
									>
									</div>
								
							
							
							
								
									<div class="card__color-more">
										
										+ 4 colors
									</div>
								
							
						</div>
					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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">
					1 699 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        1 699 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								2 880,00 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-42%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
						<div class="card__badge">
							<span
								id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-14938372866428"
								class="badge badge--bottom-left"
								style="background-color: #92b793; color: #ffffff;"
							>
								Top ventes
							</span>
						</div>
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/TRAPEZE-ECRU-_5.jpg?v=1773150492&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/TRAPEZE-ECRU-_5.jpg?v=1773150492&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/TRAPEZE-ECRU-_5.jpg?v=1773150492&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/TRAPEZE-ECRU-_5.jpg?v=1773150492&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/TRAPEZE-ECRU-_5.jpg?v=1773150492&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/TRAPEZE-ECRU-_5.jpg?v=1773150492&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/TRAPEZE-ECRU-_5.jpg?v=1773150492 3115w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/TRAPEZE-ECRU-_5.jpg?v=1773150492&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Ecru"
								class="motion-reduce"
								
								width="3115"
								height="1599"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/saint-tropez-canape-convertible-3-places-velours-couchage-140-x-190-cm-largeur-200-cm.jpg?v=1767785958&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/saint-tropez-canape-convertible-3-places-velours-couchage-140-x-190-cm-largeur-200-cm.jpg?v=1767785958&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/saint-tropez-canape-convertible-3-places-velours-couchage-140-x-190-cm-largeur-200-cm.jpg?v=1767785958&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/saint-tropez-canape-convertible-3-places-velours-couchage-140-x-190-cm-largeur-200-cm.jpg?v=1767785958&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/saint-tropez-canape-convertible-3-places-velours-couchage-140-x-190-cm-largeur-200-cm.jpg?v=1767785958&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/saint-tropez-canape-convertible-3-places-velours-couchage-140-x-190-cm-largeur-200-cm.jpg?v=1767785958&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/saint-tropez-canape-convertible-3-places-velours-couchage-140-x-190-cm-largeur-200-cm.jpg?v=1767785958 2000w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/saint-tropez-canape-convertible-3-places-velours-couchage-140-x-190-cm-largeur-200-cm.jpg?v=1767785958&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="#Ecru   convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="2000"
									height="1134"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/18122-trapeze-canape-convertible-3-places-velours-couchage-140-x-190-cm-largeur-200-cm"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877194121405"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877194121405 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877194121405"
								>
									TRAPEZE 3-seater convertible sofa - Velvet
								</a>
							</div>
						
						<p class="card__description">Length 200 cm - Sleeping area 140 x 190 cm - Double slatted base</p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877194121405"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-7877194121405"
							
						>
							<a
								href="/en/products/18122-trapeze-canape-convertible-3-places-velours-couchage-140-x-190-cm-largeur-200-cm"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877194121405"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877194121405 Badge-template--26281868263804__ax_featured_collections_hdNrga-7877194121405"
							>
								
									TRAPEZE 3-seater convertible sofa - Velvet
								
							</a> 
						</div>
						
							<p class="card__description">
								
									Length 200 cm - Sleeping area 140 x 190 cm - Double slatted base
								
							</p>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877194121405"></div>
					</div>

					
						<div class="card__color">
							
								
<div
										class="card__color-item card__color-item--active"
										style="background-color: #e2d7cf"
										data-url="/en/products/18122-trapeze-canape-convertible-3-places-velours-couchage-140-x-190-cm-largeur-200-cm?variant=44488113815741"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/saint-tropez-canape-convertible-3-places-velours-couchage-140-x-190-cm-largeur-200-cm.jpg?v=1767785958&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #c36a00"
										data-url="/en/products/18122-trapeze-canape-convertible-3-places-velours-couchage-140-x-190-cm-largeur-200-cm?variant=44488113881277"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/saint-tropez-canape-convertible-3-places-velours-couchage-140-x-190-cm-largeur-200-cm_b65b203e-0480-4882-96d8-5029f6f41e6f.jpg?v=1767785952&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #cb852d"
										data-url="/en/products/18122-trapeze-canape-convertible-3-places-velours-couchage-140-x-190-cm-largeur-200-cm?variant=44488113979581"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/saint-tropez-canape-convertible-3-places-velours-couchage-140-x-190-cm-largeur-200-cm_5a7f4898-a49d-46b7-be66-a426ce599cf0.jpg?v=1773150382&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #282a41
 chocolate"
										data-url="/en/products/18122-trapeze-canape-convertible-3-places-velours-couchage-140-x-190-cm-largeur-200-cm?variant=44488114110653"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/saint-tropez-canape-convertible-3-places-velours-couchage-140-x-190-cm-largeur-200-cm_867d0f1e-a86d-43fc-9a70-e0cf77ab09ed.jpg?v=1773150382&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #888282"
										data-url="/en/products/18122-trapeze-canape-convertible-3-places-velours-couchage-140-x-190-cm-largeur-200-cm?variant=44488113848509"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/saint-tropez-canape-convertible-3-places-velours-couchage-140-x-190-cm-largeur-200-cm_a77cffc3-a402-463d-96ac-39aa47a87e91.jpg?v=1773150382&width=675"
									>
									</div>
								
							
							
							
								
									<div class="card__color-more">
										
										+ 6 colors
									</div>
								
							
						</div>
					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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">
					1 699 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        1 699 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								2 880,73 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-42%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/Corfou-Beige-_2.jpg?v=1771597493&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/Corfou-Beige-_2.jpg?v=1771597493&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/Corfou-Beige-_2.jpg?v=1771597493&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/Corfou-Beige-_2.jpg?v=1771597493&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/Corfou-Beige-_2.jpg?v=1771597493&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/Corfou-Beige-_2.jpg?v=1771597493&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/Corfou-Beige-_2.jpg?v=1771597493 3115w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/Corfou-Beige-_2.jpg?v=1771597493&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Beige"
								class="motion-reduce"
								
								width="3115"
								height="1599"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/Corfou_Beige_1.jpg?v=1771597493&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/Corfou_Beige_1.jpg?v=1771597493&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/Corfou_Beige_1.jpg?v=1771597493&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/Corfou_Beige_1.jpg?v=1771597493&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/Corfou_Beige_1.jpg?v=1771597493&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/Corfou_Beige_1.jpg?v=1771597493&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/Corfou_Beige_1.jpg?v=1771597493 3120w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/Corfou_Beige_1.jpg?v=1771597493&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="#Beige convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="3120"
									height="1600"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/corfou-canape-convertible-3-places-velours"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-15382836969852"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-15382836969852 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-15382836969852"
								>
									CORFOU - 3-seater sofa bed - Velvet
								</a>
							</div>
						
						<p class="card__description">Length 178 cm - Sleeping area 140 x 190 cm</p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="15382836969852"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
							<div class="card__badge">
								<span
									id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-15382836969852"
									class="badge badge--bottom-left"
									style="background-color: #000000; color: #ffffff;"
								>
									Braderie
								</span>
							</div>
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-15382836969852"
							
						>
							<a
								href="/en/products/corfou-canape-convertible-3-places-velours"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-15382836969852"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-15382836969852 Badge-template--26281868263804__ax_featured_collections_hdNrga-15382836969852"
							>
								
									CORFOU - 3-seater sofa bed - Velvet
								
							</a> 
						</div>
						
							<p class="card__description">
								
									Length 178 cm - Sleeping area 140 x 190 cm
								
							</p>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="15382836969852"></div>
					</div>

					
						<div class="card__color">
							
								
<div
										class="card__color-item card__color-item--active"
										style="background-color: #000"
										data-url="/en/products/corfou-canape-convertible-3-places-velours?variant=55451317174652"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Corfou-Gris-clair-_5.jpg?v=1767366542&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #000"
										data-url="/en/products/corfou-canape-convertible-3-places-velours?variant=56201152692604"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Corfou-Gris-souris-_5.jpg?v=1767791839&width=675"
									>
									</div>
								
							
							
							
								
							
						</div>
					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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">
					1 249 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        1 249 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								2 081,00 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-40%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
						<div class="card__badge">
							<span
								id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-15382836969852"
								class="badge badge--bottom-left"
								style="background-color: #000000; color: #ffffff;"
							>
								Braderie
							</span>
						</div>
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/ATHENES-BEIGE-_2.jpg?v=1774949374&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/ATHENES-BEIGE-_2.jpg?v=1774949374&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/ATHENES-BEIGE-_2.jpg?v=1774949374&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/ATHENES-BEIGE-_2.jpg?v=1774949374&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/ATHENES-BEIGE-_2.jpg?v=1774949374&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/ATHENES-BEIGE-_2.jpg?v=1774949374&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/ATHENES-BEIGE-_2.jpg?v=1774949374 3115w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/ATHENES-BEIGE-_2.jpg?v=1774949374&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Beige"
								class="motion-reduce"
								
								width="3115"
								height="1599"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ATHENES-02.jpg?v=1770113316&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ATHENES-02.jpg?v=1770113316&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ATHENES-02.jpg?v=1770113316&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ATHENES-02.jpg?v=1770113316&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ATHENES-02.jpg?v=1770113316&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ATHENES-02.jpg?v=1770113316&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ATHENES-02.jpg?v=1770113316 3115w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ATHENES-02.jpg?v=1770113316&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="#Beige convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="3115"
									height="1599"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/athena-canape-convertible-3-places-velours"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-15374352515452"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-15374352515452 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-15374352515452"
								>
									ATHENS - 3-seater convertible sofa - Velvet
								</a>
							</div>
						
						<p class="card__description">Length 178 cm - Sleeping area 140 x 190 cm</p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="15374352515452"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-15374352515452"
							
						>
							<a
								href="/en/products/athena-canape-convertible-3-places-velours"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-15374352515452"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-15374352515452 Badge-template--26281868263804__ax_featured_collections_hdNrga-15374352515452"
							>
								
									ATHENS - 3-seater convertible sofa - Velvet
								
							</a> 
						</div>
						
							<p class="card__description">
								
									Length 178 cm - Sleeping area 140 x 190 cm
								
							</p>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="15374352515452"></div>
					</div>

					
						<div class="card__color">
							
								
<div
										class="card__color-item card__color-item--active"
										style="background-color: #000"
										data-url="/en/products/athena-canape-convertible-3-places-velours?variant=55437179519356"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/ATHENES-BEIGE-_2.jpg?v=1774949374&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #000"
										data-url="/en/products/athena-canape-convertible-3-places-velours?variant=55437179486588"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/ATHENES-ECRU-_3.jpg?v=1774949374&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #000"
										data-url="/en/products/athena-canape-convertible-3-places-velours?variant=55437179552124"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/ATHENES-VERT-DEAU-_3.jpg?v=1774949374&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #282a41
 chocolate"
										data-url="/en/products/athena-canape-convertible-3-places-velours?variant=55437179584892"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/ATHENES-BLEU-MARINE-_3.jpg?v=1774949374&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #000"
										data-url="/en/products/athena-canape-convertible-3-places-velours?variant=55437179617660"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/ATHENES-GRIS-CLAIR-_3.jpg?v=1774949374&width=675"
									>
									</div>
								
							
							
							
								
									<div class="card__color-more">
										
										+ 4 colors
									</div>
								
							
						</div>
					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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">
					1 399 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        1 399 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								3 108,00 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-55%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/marseille-beige-1.jpg?v=1770199504&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/marseille-beige-1.jpg?v=1770199504&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/marseille-beige-1.jpg?v=1770199504&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/marseille-beige-1.jpg?v=1770199504&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/marseille-beige-1.jpg?v=1770199504&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/marseille-beige-1.jpg?v=1770199504&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/marseille-beige-1.jpg?v=1770199504 3115w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/marseille-beige-1.jpg?v=1770199504&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Beige"
								class="motion-reduce"
								
								width="3115"
								height="1599"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/marseille-beige-4.jpg?v=1770199504&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/marseille-beige-4.jpg?v=1770199504&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/marseille-beige-4.jpg?v=1770199504&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/marseille-beige-4.jpg?v=1770199504&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/marseille-beige-4.jpg?v=1770199504&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/marseille-beige-4.jpg?v=1770199504&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/marseille-beige-4.jpg?v=1770199504 3115w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/marseille-beige-4.jpg?v=1770199504&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="#Beige convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="3115"
									height="1599"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/10141-marseille-canape-convertible-3-places-tweed-couchage-140-x-190-cm-largeur-170-cm-sommier-doubles-lattes"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877002985661"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877002985661 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877002985661"
								>
									MARSEILLE - 3-seater convertible sofa - Tweed
								</a>
							</div>
						
						<p class="card__description">Length 170 cm - Sleeping area 140 x 190 cm - Double slatted base</p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877002985661"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-7877002985661"
							
						>
							<a
								href="/en/products/10141-marseille-canape-convertible-3-places-tweed-couchage-140-x-190-cm-largeur-170-cm-sommier-doubles-lattes"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877002985661"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877002985661 Badge-template--26281868263804__ax_featured_collections_hdNrga-7877002985661"
							>
								
									MARSEILLE - 3-seater convertible sofa - Tweed
								
							</a> 
						</div>
						
							<p class="card__description">
								
									Length 170 cm - Sleeping area 140 x 190 cm - Double slatted base
								
							</p>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877002985661"></div>
					</div>

					
						<div class="card__color">
							
								
<div
										class="card__color-item card__color-item--active"
										style="background-color: #bfad97"
										data-url="/en/products/10141-marseille-canape-convertible-3-places-tweed-couchage-140-x-190-cm-largeur-170-cm-sommier-doubles-lattes?variant=44487590707389"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/marseille-beige-1.jpg?v=1770199504&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #000"
										data-url="/en/products/10141-marseille-canape-convertible-3-places-tweed-couchage-140-x-190-cm-largeur-170-cm-sommier-doubles-lattes?variant=55533757890940"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Marseille-vert-sapin-_1_b920bd50-b861-4b44-8922-6ec561498c25.jpg?v=1770199504&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #888282"
										data-url="/en/products/10141-marseille-canape-convertible-3-places-tweed-couchage-140-x-190-cm-largeur-170-cm-sommier-doubles-lattes?variant=44487590772925"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/marseille-gris-clair-1.jpg?v=1770199488&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #e2d7cf"
										data-url="/en/products/10141-marseille-canape-convertible-3-places-tweed-couchage-140-x-190-cm-largeur-170-cm-sommier-doubles-lattes?variant=44487590969533"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Marseille-ecru-_2.jpg?v=1770199504&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #282a41
 chocolate"
										data-url="/en/products/10141-marseille-canape-convertible-3-places-tweed-couchage-140-x-190-cm-largeur-170-cm-sommier-doubles-lattes?variant=44487590740157"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/marseille-bleu-marine-1.jpg?v=1770199504&width=675"
									>
									</div>
								
							
							
							
								
									<div class="card__color-more">
										
										+ 6 colors
									</div>
								
							
						</div>
					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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">
					1 189 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        1 189 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								2 431,45 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-52%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/ECRU-AURON-Loop-2-Front.jpg?v=1772035174&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/ECRU-AURON-Loop-2-Front.jpg?v=1772035174&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/ECRU-AURON-Loop-2-Front.jpg?v=1772035174&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/ECRU-AURON-Loop-2-Front.jpg?v=1772035174&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/ECRU-AURON-Loop-2-Front.jpg?v=1772035174&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/ECRU-AURON-Loop-2-Front.jpg?v=1772035174&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/ECRU-AURON-Loop-2-Front.jpg?v=1772035174 3115w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/ECRU-AURON-Loop-2-Front.jpg?v=1772035174&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Ecru"
								class="motion-reduce"
								
								width="3115"
								height="1599"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ISOLA.jpg?v=1772035174&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ISOLA.jpg?v=1772035174&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ISOLA.jpg?v=1772035174&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ISOLA.jpg?v=1772035174&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ISOLA.jpg?v=1772035174&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ISOLA.jpg?v=1772035174&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ISOLA.jpg?v=1772035174 2524w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ISOLA.jpg?v=1772035174&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="#Ecru convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="2524"
									height="1296"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/auron-canape-convertible-4-places-velours-bouclette"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-14963438256508"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-14963438256508 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-14963438256508"
								>
									AURON - 3-seater convertible sofa - Terry cloth fabric
								</a>
							</div>
						
						<p class="card__description">Length 194cm - sleeping area 140 x 190 cm - Double slatted base</p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="14963438256508"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-14963438256508"
							
						>
							<a
								href="/en/products/auron-canape-convertible-4-places-velours-bouclette"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-14963438256508"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-14963438256508 Badge-template--26281868263804__ax_featured_collections_hdNrga-14963438256508"
							>
								
									AURON - 3-seater convertible sofa - Terry cloth fabric
								
							</a> 
						</div>
						
							<p class="card__description">
								
									Length 194cm - sleeping area 140 x 190 cm - Double slatted base
								
							</p>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="14963438256508"></div>
					</div>

					
						<div class="card__color">
							
								
<div
										class="card__color-item card__color-item--active"
										style="background-color: #e2d7cf"
										data-url="/en/products/auron-canape-convertible-4-places-velours-bouclette?variant=54878698242428"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/ECRU-AURON-Loop-2-Front.jpg?v=1772035174&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #000"
										data-url="/en/products/auron-canape-convertible-4-places-velours-bouclette?variant=54878698504572"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/BEIGE-AURON-Loop-07-Front.jpg?v=1771233975&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #000"
										data-url="/en/products/auron-canape-convertible-4-places-velours-bouclette?variant=54878698439036"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/GRIS-CLAIR-AURON-Loop-17-Front.jpg?v=1771233975&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #000"
										data-url="/en/products/auron-canape-convertible-4-places-velours-bouclette?variant=54878698275196"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/ROUILLE-AURON-Loop-10-Front.jpg?v=1771233975&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #8e0109
 mustard"
										data-url="/en/products/auron-canape-convertible-4-places-velours-bouclette?variant=54878698307964"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/ROUGE-AURON-Loop-09-Front.jpg?v=1771233975&width=675"
									>
									</div>
								
							
							
							
								
									<div class="card__color-more">
										
										+ 6 colors
									</div>
								
							
						</div>
					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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">
					1 699 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        1 699 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								3 398,00 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-50%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/MILANO-TAUPE-CLAIR-_1.jpg?v=1765536610&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/MILANO-TAUPE-CLAIR-_1.jpg?v=1765536610&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/MILANO-TAUPE-CLAIR-_1.jpg?v=1765536610&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/MILANO-TAUPE-CLAIR-_1.jpg?v=1765536610&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/MILANO-TAUPE-CLAIR-_1.jpg?v=1765536610&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/MILANO-TAUPE-CLAIR-_1.jpg?v=1765536610&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/MILANO-TAUPE-CLAIR-_1.jpg?v=1765536610 3115w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/MILANO-TAUPE-CLAIR-_1.jpg?v=1765536610&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Taupe clair"
								class="motion-reduce"
								
								width="3115"
								height="1599"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-MILANO.jpg?v=1767007547&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-MILANO.jpg?v=1767007547&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-MILANO.jpg?v=1767007547&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-MILANO.jpg?v=1767007547&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-MILANO.jpg?v=1767007547&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-MILANO.jpg?v=1767007547&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-MILANO.jpg?v=1767007547 3115w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-MILANO.jpg?v=1767007547&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="MILANO - 3 seater convertible sofa - Tweed convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="3115"
									height="1599"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/17951-canape-convertible-3-places-milano-largeur-188-cm-matelas-16-cm-couchage-140-cm-sommier-doubles-lattes-larges"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877108760765"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877108760765 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877108760765"
								>
									MILANO - 3 seater convertible sofa - Tweed
								</a>
							</div>
						
						<p class="card__description">Length 188 cm - Bed 140 x 190 cm - Double slatted base - Mattress 16 cm </p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877108760765"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
							<div class="card__badge">
								<span
									id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877108760765"
									class="badge badge--bottom-left"
									style="background-color: #c9a94d; color: #ffffff;"
								>
									Matelas 16cm
								</span>
							</div>
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-7877108760765"
							
						>
							<a
								href="/en/products/17951-canape-convertible-3-places-milano-largeur-188-cm-matelas-16-cm-couchage-140-cm-sommier-doubles-lattes-larges"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877108760765"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877108760765 Badge-template--26281868263804__ax_featured_collections_hdNrga-7877108760765"
							>
								
									MILANO - 3 seater convertible sofa - Tweed
								
							</a> 
						</div>
						
							<p class="card__description">
								
									Length 188 cm - Bed 140 x 190 cm - Double slatted base - Mattress 16 cm 
								
							</p>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877108760765"></div>
					</div>

					
						<div class="card__color">
							
								
<div
										class="card__color-item card__color-item--active"
										style="background-color: #978272
 aqua green"
										data-url="/en/products/17951-canape-convertible-3-places-milano-largeur-188-cm-matelas-16-cm-couchage-140-cm-sommier-doubles-lattes-larges?variant=44487880278205"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/MILANO-TAUPE-CLAIR-_1.jpg?v=1765536610&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #e2d7cf"
										data-url="/en/products/17951-canape-convertible-3-places-milano-largeur-188-cm-matelas-16-cm-couchage-140-cm-sommier-doubles-lattes-larges?variant=44487880179901"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/MILANO-ECRU-_1.jpg?v=1767007498&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #888282"
										data-url="/en/products/17951-canape-convertible-3-places-milano-largeur-188-cm-matelas-16-cm-couchage-140-cm-sommier-doubles-lattes-larges?variant=44487879622845"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/MILANO-GRIS-CLAIR-_1.jpg?v=1767007498&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #494c4a"
										data-url="/en/products/17951-canape-convertible-3-places-milano-largeur-188-cm-matelas-16-cm-couchage-140-cm-sommier-doubles-lattes-larges?variant=44487879721149"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/MILANO-GRIS-SOURIS-_4.jpg?v=1767007498&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #2d2f2e"
										data-url="/en/products/17951-canape-convertible-3-places-milano-largeur-188-cm-matelas-16-cm-couchage-140-cm-sommier-doubles-lattes-larges?variant=44487879786685"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/MILANO-GRIS-ANTHRACITE-_1.jpg?v=1767007498&width=675"
									>
									</div>
								
							
							
							
								
									<div class="card__color-more">
										
										+ 6 colors
									</div>
								
							
						</div>
					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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">
					1 299 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        1 299 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								2 835,58 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-55%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
						<div class="card__badge">
							<span
								id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877108760765"
								class="badge badge--bottom-left"
								style="background-color: #c9a94d; color: #ffffff;"
							>
								Matelas 16cm
							</span>
						</div>
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm_Gris_clair_0.jpg?v=1770738820&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm_Gris_clair_0.jpg?v=1770738820&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm_Gris_clair_0.jpg?v=1770738820&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm_Gris_clair_0.jpg?v=1770738820&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm_Gris_clair_0.jpg?v=1770738820&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm_Gris_clair_0.jpg?v=1770738820&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm_Gris_clair_0.jpg?v=1770738820 3115w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm_Gris_clair_0.jpg?v=1770738820&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Gris clair"
								class="motion-reduce"
								
								width="3115"
								height="1599"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm_Gris_clair_1.jpg?v=1770738820&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm_Gris_clair_1.jpg?v=1770738820&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm_Gris_clair_1.jpg?v=1770738820&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm_Gris_clair_1.jpg?v=1770738820&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm_Gris_clair_1.jpg?v=1770738820&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm_Gris_clair_1.jpg?v=1770738820&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm_Gris_clair_1.jpg?v=1770738820 3115w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm_Gris_clair_1.jpg?v=1770738820&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="#Gris clair convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="3115"
									height="1599"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877146116285"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877146116285 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877146116285"
								>
									BEAULIEU - 3-seater convertible sofa - Tweed
								</a>
							</div>
						
						<p class="card__description">Length 170 cm - Bed 140 x 190 cm - Double slatted base </p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877146116285"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
							<div class="card__badge">
								<span
									id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877146116285"
									class="badge badge--bottom-left"
									style="background-color: #000000; color: #ffffff;"
								>
									Braderie
								</span>
							</div>
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-7877146116285"
							
						>
							<a
								href="/en/products/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877146116285"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877146116285 Badge-template--26281868263804__ax_featured_collections_hdNrga-7877146116285"
							>
								
									BEAULIEU - 3-seater convertible sofa - Tweed
								
							</a> 
						</div>
						
							<p class="card__description">
								
									Length 170 cm - Bed 140 x 190 cm - Double slatted base 
								
							</p>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877146116285"></div>
					</div>

					
						<div class="card__color">
							
								
<div
										class="card__color-item card__color-item--active"
										style="background-color: #888282"
										data-url="/en/products/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm?variant=44487987298493"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm_Gris_clair_0.jpg?v=1770738820&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #494c4a"
										data-url="/en/products/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm?variant=44487987331261"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm_Gris_souris_39.jpg?v=1770738820&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #355000
 bluish grey"
										data-url="/en/products/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm?variant=44487987200189"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm_Kaki_33.jpg?v=1770738713&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #cb852d"
										data-url="/en/products/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm?variant=44487987232957"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm_Moutarde_27.jpg?v=1770738713&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #e2d7cf"
										data-url="/en/products/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm?variant=44487987036349"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/18050-canape-convertible-3-places-beaulieu-couchage-140-x-190-cm-largeur-170-cm_Ecru_51.jpg?v=1770738820&width=675"
									>
									</div>
								
							
							
							
								
									<div class="card__color-more">
										
										+ 6 colors
									</div>
								
							
						</div>
					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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">
					1 199 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        1 199 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								2 398,00 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-50%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
						<div class="card__badge">
							<span
								id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877146116285"
								class="badge badge--bottom-left"
								style="background-color: #000000; color: #ffffff;"
							>
								Braderie
							</span>
						</div>
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/Manosque-Ecru-_1.jpg?v=1767608264&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/Manosque-Ecru-_1.jpg?v=1767608264&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/Manosque-Ecru-_1.jpg?v=1767608264&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/Manosque-Ecru-_1.jpg?v=1767608264&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/Manosque-Ecru-_1.jpg?v=1767608264&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/Manosque-Ecru-_1.jpg?v=1767608264&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/Manosque-Ecru-_1.jpg?v=1767608264 3115w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/Manosque-Ecru-_1.jpg?v=1767608264&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Ecru"
								class="motion-reduce"
								
								width="3115"
								height="1599"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-MILANO-MANOSQUE-ANGLE.jpg?v=1773136295&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-MILANO-MANOSQUE-ANGLE.jpg?v=1773136295&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-MILANO-MANOSQUE-ANGLE.jpg?v=1773136295&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-MILANO-MANOSQUE-ANGLE.jpg?v=1773136295&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-MILANO-MANOSQUE-ANGLE.jpg?v=1773136295&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-MILANO-MANOSQUE-ANGLE.jpg?v=1773136295&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-MILANO-MANOSQUE-ANGLE.jpg?v=1773136295 3115w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-MILANO-MANOSQUE-ANGLE.jpg?v=1773136295&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="MANOSQUE - 5-seater convertible corner sofa - Tweed convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="3115"
									height="1599"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/17620-manosque-canape-d-angle-convertible-tweed-meridienne-reversible-couchage-140-cm-largeur-268-cm"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877031854269"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877031854269 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877031854269"
								>
									MANOSQUE - 5-seater convertible corner sofa - Tweed
								</a>
							</div>
						
						<p class="card__description">Length 268 cm - Bed 140 x 190 cm - Double slatted base - Reversible chaise longue</p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877031854269"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
							<div class="card__badge">
								<span
									id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877031854269"
									class="badge badge--bottom-left"
									style="background-color: #92b793; color: #ffffff;"
								>
									Top ventes
								</span>
							</div>
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-7877031854269"
							
						>
							<a
								href="/en/products/17620-manosque-canape-d-angle-convertible-tweed-meridienne-reversible-couchage-140-cm-largeur-268-cm"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877031854269"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877031854269 Badge-template--26281868263804__ax_featured_collections_hdNrga-7877031854269"
							>
								
									MANOSQUE - 5-seater convertible corner sofa - Tweed
								
							</a> 
						</div>
						
							<p class="card__description">
								
									Length 268 cm - Bed 140 x 190 cm - Double slatted base - Reversible chaise longue
								
							</p>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877031854269"></div>
					</div>

					
						<div class="card__color">
							
								
<div
										class="card__color-item card__color-item--active"
										style="background-color: #e2d7cf"
										data-url="/en/products/17620-manosque-canape-d-angle-convertible-tweed-meridienne-reversible-couchage-140-cm-largeur-268-cm?variant=44487695794365"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Manosque-Ecru-_1.jpg?v=1767608264&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #bfad97"
										data-url="/en/products/17620-manosque-canape-d-angle-convertible-tweed-meridienne-reversible-couchage-140-cm-largeur-268-cm?variant=44487695532221"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Manosque-angle-beige-_1.jpg?v=1767608264&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #888282"
										data-url="/en/products/17620-manosque-canape-d-angle-convertible-tweed-meridienne-reversible-couchage-140-cm-largeur-268-cm?variant=44487695564989"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Manosque-Gris-clair-_1_fcf2380a-0a96-41c8-94c4-2c0f599c6080.jpg?v=1767608228&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #494c4a"
										data-url="/en/products/17620-manosque-canape-d-angle-convertible-tweed-meridienne-reversible-couchage-140-cm-largeur-268-cm?variant=44487695597757"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Manosque-gris-souris-_1_d84500cc-89da-426c-ad60-eef9fe3f4c42.jpg?v=1767607875&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #cb852d"
										data-url="/en/products/17620-manosque-canape-d-angle-convertible-tweed-meridienne-reversible-couchage-140-cm-largeur-268-cm?variant=44487695630525"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Manosque-moutarde-_1_10fc4896-971f-4a9e-a547-a472aea5830b.jpg?v=1767608264&width=675"
									>
									</div>
								
							
							
							
								
									<div class="card__color-more">
										
										+ 6 colors
									</div>
								
							
						</div>
					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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">
					1 999 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        1 999 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								4 216,00 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-53%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
						<div class="card__badge">
							<span
								id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877031854269"
								class="badge badge--bottom-left"
								style="background-color: #92b793; color: #ffffff;"
							>
								Top ventes
							</span>
						</div>
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/FORMENTERA_ECRU_2.jpg?v=1750336837&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/FORMENTERA_ECRU_2.jpg?v=1750336837&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/FORMENTERA_ECRU_2.jpg?v=1750336837&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/FORMENTERA_ECRU_2.jpg?v=1750336837&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/FORMENTERA_ECRU_2.jpg?v=1750336837&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/FORMENTERA_ECRU_2.jpg?v=1750336837&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/FORMENTERA_ECRU_2.jpg?v=1750336837 3120w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/FORMENTERA_ECRU_2.jpg?v=1750336837&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Ecru"
								class="motion-reduce"
								
								width="3120"
								height="1600"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/FORMENTERA_ECRU_7.jpg?v=1750336837&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/FORMENTERA_ECRU_7.jpg?v=1750336837&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/FORMENTERA_ECRU_7.jpg?v=1750336837&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/FORMENTERA_ECRU_7.jpg?v=1750336837&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/FORMENTERA_ECRU_7.jpg?v=1750336837&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/FORMENTERA_ECRU_7.jpg?v=1750336837&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/FORMENTERA_ECRU_7.jpg?v=1750336837 3120w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/FORMENTERA_ECRU_7.jpg?v=1750336837&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="#Ecru convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="3120"
									height="1600"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/formentera-canape-convertible-4-places-lin"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-15388199158140"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-15388199158140 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-15388199158140"
								>
									FORMENTERA - 4-seater sofa bed - Linen
								</a>
							</div>
						
						<p class="card__description">Length 209 cm - Sleeping area 160 x 190 cm</p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="15388199158140"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
							<div class="card__badge">
								<span
									id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-15388199158140"
									class="badge badge--bottom-left"
									style="background-color: #000000; color: #ffffff;"
								>
									Braderie
								</span>
							</div>
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-15388199158140"
							
						>
							<a
								href="/en/products/formentera-canape-convertible-4-places-lin"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-15388199158140"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-15388199158140 Badge-template--26281868263804__ax_featured_collections_hdNrga-15388199158140"
							>
								
									FORMENTERA - 4-seater sofa bed - Linen
								
							</a> 
						</div>
						
							<p class="card__description">
								
									Length 209 cm - Sleeping area 160 x 190 cm
								
							</p>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="15388199158140"></div>
					</div>

					
						<div class="card__color">
							
								
<div
										class="card__color-item card__color-item--active"
										style="background-color: #000"
										data-url="/en/products/formentera-canape-convertible-4-places-lin?variant=55460937204092"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/FORMENTERA_BEIGE_3.jpg?v=1750336837&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #e2d7cf"
										data-url="/en/products/formentera-canape-convertible-4-places-lin?variant=55460937236860"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/FORMENTERA_ECRU_2.jpg?v=1750336837&width=675"
									>
									</div>
								
							
							
							
								
							
						</div>
					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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">
					1 699 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        1 699 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								3 398,00 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-50%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
						<div class="card__badge">
							<span
								id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-15388199158140"
								class="badge badge--bottom-left"
								style="background-color: #000000; color: #ffffff;"
							>
								Braderie
							</span>
						</div>
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/ATHENES-ECRU-_3.jpg?v=1774949374&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/ATHENES-ECRU-_3.jpg?v=1774949374&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/ATHENES-ECRU-_3.jpg?v=1774949374&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/ATHENES-ECRU-_3.jpg?v=1774949374&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/ATHENES-ECRU-_3.jpg?v=1774949374&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/ATHENES-ECRU-_3.jpg?v=1774949374&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/ATHENES-ECRU-_3.jpg?v=1774949374 3115w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/ATHENES-ECRU-_3.jpg?v=1774949374&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Blanc cassé"
								class="motion-reduce"
								
								width="3115"
								height="1599"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ATHENES.jpg?v=1774949374&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ATHENES.jpg?v=1774949374&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ATHENES.jpg?v=1774949374&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ATHENES.jpg?v=1774949374&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ATHENES.jpg?v=1774949374&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ATHENES.jpg?v=1774949374&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ATHENES.jpg?v=1774949374 3115w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-ATHENES.jpg?v=1774949374&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="ATHENS - 4-seater convertible sofa - Velvet convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="3115"
									height="1599"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/athenes-canape-convertible-4-places-velours"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-15375137538428"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-15375137538428 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-15375137538428"
								>
									ATHENS - 4-seater convertible sofa - Velvet
								</a>
							</div>
						
						<p class="card__description">Length 198 cm - Sleeping area 160 x 190 cm</p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="15375137538428"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-15375137538428"
							
						>
							<a
								href="/en/products/athenes-canape-convertible-4-places-velours"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-15375137538428"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-15375137538428 Badge-template--26281868263804__ax_featured_collections_hdNrga-15375137538428"
							>
								
									ATHENS - 4-seater convertible sofa - Velvet
								
							</a> 
						</div>
						
							<p class="card__description">
								
									Length 198 cm - Sleeping area 160 x 190 cm
								
							</p>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="15375137538428"></div>
					</div>

					
						<div class="card__color">
							
								
<div
										class="card__color-item card__color-item--active"
										style="background-color: #000"
										data-url="/en/products/athenes-canape-convertible-4-places-velours?variant=55438832730492"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/ATHENES-ECRU-_3.jpg?v=1774949374&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #000"
										data-url="/en/products/athenes-canape-convertible-4-places-velours?variant=55438832763260"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/ATHENES-BEIGE-_2.jpg?v=1774949374&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #000"
										data-url="/en/products/athenes-canape-convertible-4-places-velours?variant=55438832959868"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/ATHENES-BLEU-CIEL-_3.jpg?v=1774949374&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #000"
										data-url="/en/products/athenes-canape-convertible-4-places-velours?variant=55438832861564"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/ATHENES-GRIS-CLAIR-_3.jpg?v=1774949374&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #000"
										data-url="/en/products/athenes-canape-convertible-4-places-velours?variant=55438832796028"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/ATHENES-VERT-DEAU-_3.jpg?v=1774949374&width=675"
									>
									</div>
								
							
							
							
								
									<div class="card__color-more">
										
										+ 4 colors
									</div>
								
							
						</div>
					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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">
					1 599 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        1 599 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								3 553,00 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-55%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/Lourdesecru_4.jpg?v=1747128934&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/Lourdesecru_4.jpg?v=1747128934&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/Lourdesecru_4.jpg?v=1747128934&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/Lourdesecru_4.jpg?v=1747128934&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/Lourdesecru_4.jpg?v=1747128934&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/Lourdesecru_4.jpg?v=1747128934&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/Lourdesecru_4.jpg?v=1747128934 3120w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/Lourdesecru_4.jpg?v=1747128934&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Ecru"
								class="motion-reduce"
								
								width="3120"
								height="1600"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/Lourdesecru_2.jpg?v=1747128934&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/Lourdesecru_2.jpg?v=1747128934&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/Lourdesecru_2.jpg?v=1747128934&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/Lourdesecru_2.jpg?v=1747128934&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/Lourdesecru_2.jpg?v=1747128934&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/Lourdesecru_2.jpg?v=1747128934&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/Lourdesecru_2.jpg?v=1747128934 3120w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/Lourdesecru_2.jpg?v=1747128934&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="#Ecru convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="3120"
									height="1600"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/lourdes-grand-canape-convertible-4-places-tweed"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-15268850041212"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-15268850041212 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-15268850041212"
								>
									LOURDES - Large 4-seater convertible sofa - Tweed
								</a>
							</div>
						
						<p class="card__description">Length 200 cm - Bed 160 x 190 cm - Double slatted base</p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="15268850041212"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-15268850041212"
							
						>
							<a
								href="/en/products/lourdes-grand-canape-convertible-4-places-tweed"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-15268850041212"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-15268850041212 Badge-template--26281868263804__ax_featured_collections_hdNrga-15268850041212"
							>
								
									LOURDES - Large 4-seater convertible sofa - Tweed
								
							</a> 
						</div>
						
							<p class="card__description">
								
									Length 200 cm - Bed 160 x 190 cm - Double slatted base
								
							</p>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="15268850041212"></div>
					</div>

					
						<div class="card__color">
							
								
<div
										class="card__color-item card__color-item--active"
										style="background-color: #e2d7cf"
										data-url="/en/products/lourdes-grand-canape-convertible-4-places-tweed?variant=55238891176316"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Lourdesecru_4.jpg?v=1747128934&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #282a41
 chocolate"
										data-url="/en/products/lourdes-grand-canape-convertible-4-places-tweed?variant=55238891209084"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Lourdesbleumarine_5_3ef42dac-5d59-4dc3-920a-09c3edf7ca22.jpg?v=1747128915&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #888282"
										data-url="/en/products/lourdes-grand-canape-convertible-4-places-tweed?variant=55238891241852"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Lourdesgrisclair_4.jpg?v=1747128934&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #8e0109
 mustard"
										data-url="/en/products/lourdes-grand-canape-convertible-4-places-tweed?variant=55238891471228"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Lourdeesrouge_5.jpg?v=1747128934&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #355000
 bluish grey"
										data-url="/en/products/lourdes-grand-canape-convertible-4-places-tweed?variant=55238892224892"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Lourdeskaki_4.jpg?v=1747128934&width=675"
									>
									</div>
								
							
							
							
								
							
						</div>
					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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">
					1 449 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        1 449 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								2 940,00 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-51%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/PALAVAS_ROUILLE_2.jpg?v=1747744315&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/PALAVAS_ROUILLE_2.jpg?v=1747744315&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/PALAVAS_ROUILLE_2.jpg?v=1747744315&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/PALAVAS_ROUILLE_2.jpg?v=1747744315&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/PALAVAS_ROUILLE_2.jpg?v=1747744315&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/PALAVAS_ROUILLE_2.jpg?v=1747744315&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/PALAVAS_ROUILLE_2.jpg?v=1747744315 3120w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/PALAVAS_ROUILLE_2.jpg?v=1747744315&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Rouille"
								class="motion-reduce"
								
								width="3120"
								height="1599"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/Famille_Paris_Rouille_1.jpg?v=1753101817&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/Famille_Paris_Rouille_1.jpg?v=1753101817&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/Famille_Paris_Rouille_1.jpg?v=1753101817&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/Famille_Paris_Rouille_1.jpg?v=1753101817&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/Famille_Paris_Rouille_1.jpg?v=1753101817&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/Famille_Paris_Rouille_1.jpg?v=1753101817&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/Famille_Paris_Rouille_1.jpg?v=1753101817 3119w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/Famille_Paris_Rouille_1.jpg?v=1753101817&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="#Rouille convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="3119"
									height="1600"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/palavas-grand-canape-convertible-4-places-velours"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-15277774635388"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-15277774635388 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-15277774635388"
								>
									PALAVAS - Large 4-seater convertible sofa - Velvet
								</a>
							</div>
						
						<p class="card__description">Length 200 cm - Bed 160 x 190 cm - Double slatted base</p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="15277774635388"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
							<div class="card__badge">
								<span
									id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-15277774635388"
									class="badge badge--bottom-left"
									style="background-color: #92b793; color: #ffffff;"
								>
									Nouveauté
								</span>
							</div>
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-15277774635388"
							
						>
							<a
								href="/en/products/palavas-grand-canape-convertible-4-places-velours"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-15277774635388"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-15277774635388 Badge-template--26281868263804__ax_featured_collections_hdNrga-15277774635388"
							>
								
									PALAVAS - Large 4-seater convertible sofa - Velvet
								
							</a> 
						</div>
						
							<p class="card__description">
								
									Length 200 cm - Bed 160 x 190 cm - Double slatted base
								
							</p>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="15277774635388"></div>
					</div>

					
						<div class="card__color">
							
								
<div
										class="card__color-item card__color-item--active"
										style="background-color: #e2d7cf"
										data-url="/en/products/palavas-grand-canape-convertible-4-places-velours?variant=55254546481532"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/PALAVAS_ECRU_2_0ce0432e-ff6b-4b13-b8eb-e977d4e11e89.jpg?v=1747744315&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #282a41
 chocolate"
										data-url="/en/products/palavas-grand-canape-convertible-4-places-velours?variant=55254546514300"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/palavas_bleu_marine_2.jpg?v=1747744315&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #888282"
										data-url="/en/products/palavas-grand-canape-convertible-4-places-velours?variant=55254546547068"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/PALAVAS_GRIS_CLAIR_2_6daf950f-baab-409e-82c5-3c8a90e21585.jpg?v=1747744315&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #494c4a"
										data-url="/en/products/palavas-grand-canape-convertible-4-places-velours?variant=55254546579836"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/PALAVAS_GRIS_SOURIS_2_59f7ca70-1d02-49a4-b98b-8fee8aedfa28.jpg?v=1747744315&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #bfad97"
										data-url="/en/products/palavas-grand-canape-convertible-4-places-velours?variant=55254546710908"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/PALAVAS_BEIGE_2_4a9b5b05-9d10-4ba0-82ff-e00b2a57e317.jpg?v=1747744315&width=675"
									>
									</div>
								
							
							
							
								
									<div class="card__color-more">
										
										+ 5 colors
									</div>
								
							
						</div>
					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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">
					1 599 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        1 599 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								3 099,00 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-49%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
						<div class="card__badge">
							<span
								id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-15277774635388"
								class="badge badge--bottom-left"
								style="background-color: #92b793; color: #ffffff;"
							>
								Nouveauté
							</span>
						</div>
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/IBIZA_BEIGE_2.jpg?v=1750335079&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_BEIGE_2.jpg?v=1750335079&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_BEIGE_2.jpg?v=1750335079&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_BEIGE_2.jpg?v=1750335079&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_BEIGE_2.jpg?v=1750335079&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_BEIGE_2.jpg?v=1750335079&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_BEIGE_2.jpg?v=1750335079 3120w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/IBIZA_BEIGE_2.jpg?v=1750335079&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Beige"
								class="motion-reduce"
								
								width="3120"
								height="1600"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/IBIZA_BEIGE_1.jpg?v=1750335201&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_BEIGE_1.jpg?v=1750335201&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_BEIGE_1.jpg?v=1750335201&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_BEIGE_1.jpg?v=1750335201&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_BEIGE_1.jpg?v=1750335201&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_BEIGE_1.jpg?v=1750335201&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/IBIZA_BEIGE_1.jpg?v=1750335201 3120w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/IBIZA_BEIGE_1.jpg?v=1750335201&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="#Beige convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="3120"
									height="1600"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/ibiza-canape-convertible-4-places-lin"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-15388141814140"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-15388141814140 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-15388141814140"
								>
									IBIZA - 4-seater sofa bed - Linen
								</a>
							</div>
						
						<p class="card__description">Length 205 cm - Sleeping area 160 x 190 cm</p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="15388141814140"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-15388141814140"
							
						>
							<a
								href="/en/products/ibiza-canape-convertible-4-places-lin"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-15388141814140"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-15388141814140 Badge-template--26281868263804__ax_featured_collections_hdNrga-15388141814140"
							>
								
									IBIZA - 4-seater sofa bed - Linen
								
							</a> 
						</div>
						
							<p class="card__description">
								
									Length 205 cm - Sleeping area 160 x 190 cm
								
							</p>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="15388141814140"></div>
					</div>

					
						<div class="card__color">
							
								
<div
										class="card__color-item card__color-item--active"
										style="background-color: #000"
										data-url="/en/products/ibiza-canape-convertible-4-places-lin?variant=55460754030972"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/IBIZA_BEIGE_2.jpg?v=1750335079&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #e2d7cf"
										data-url="/en/products/ibiza-canape-convertible-4-places-lin?variant=55460754063740"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/IBIZA_ECRU_2.jpg?v=1768295635&width=675"
									>
									</div>
								
							
							
							
								
							
						</div>
					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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">
					1 999 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        1 999 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								3 998,00 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-50%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/Lyon_Ecru_4_-min.jpg?v=1759753645&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/Lyon_Ecru_4_-min.jpg?v=1759753645&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/Lyon_Ecru_4_-min.jpg?v=1759753645&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/Lyon_Ecru_4_-min.jpg?v=1759753645&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/Lyon_Ecru_4_-min.jpg?v=1759753645&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/Lyon_Ecru_4_-min.jpg?v=1759753645&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/Lyon_Ecru_4_-min.jpg?v=1759753645 3120w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/Lyon_Ecru_4_-min.jpg?v=1759753645&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Ecru"
								class="motion-reduce"
								
								width="3120"
								height="1600"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/Lyon_Ecru_2_-min.jpg?v=1759753645&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/Lyon_Ecru_2_-min.jpg?v=1759753645&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/Lyon_Ecru_2_-min.jpg?v=1759753645&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/Lyon_Ecru_2_-min.jpg?v=1759753645&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/Lyon_Ecru_2_-min.jpg?v=1759753645&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/Lyon_Ecru_2_-min.jpg?v=1759753645&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/Lyon_Ecru_2_-min.jpg?v=1759753645 3120w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/Lyon_Ecru_2_-min.jpg?v=1759753645&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="#Ecru convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="3120"
									height="1583"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/lyon-canape-lit-4-places-tweed"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-15179519132028"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-15179519132028 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-15179519132028"
								>
									LYON - 2-seater sofa bed without armrest - Tweed
								</a>
							</div>
						
						<p class="card__description">Length 150 cm - Sleeping area 120 x 190 cm - Double slatted base</p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="15179519132028"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-15179519132028"
							
						>
							<a
								href="/en/products/lyon-canape-lit-4-places-tweed"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-15179519132028"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-15179519132028 Badge-template--26281868263804__ax_featured_collections_hdNrga-15179519132028"
							>
								
									LYON - 2-seater sofa bed without armrest - Tweed
								
							</a> 
						</div>
						
							<p class="card__description">
								
									Length 150 cm - Sleeping area 120 x 190 cm - Double slatted base
								
							</p>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="15179519132028"></div>
					</div>

					
						<div class="card__color">
							
								
<div
										class="card__color-item card__color-item--active"
										style="background-color: #e2d7cf"
										data-url="/en/products/lyon-canape-lit-4-places-tweed?variant=55108703256956"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Lyon_Ecru_4_-min.jpg?v=1759753645&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #282a41
 chocolate"
										data-url="/en/products/lyon-canape-lit-4-places-tweed?variant=55108703224188"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/LyonBleumarine_4.jpg?v=1759753645&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #888282"
										data-url="/en/products/lyon-canape-lit-4-places-tweed?variant=55108703289724"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Lyon_gris_clair_4_-min.jpg?v=1744971371&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #8e0109
 mustard"
										data-url="/en/products/lyon-canape-lit-4-places-tweed?variant=55108703322492"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Lyon_Rouge_5_-min.jpg?v=1759753645&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #355000
 bluish grey"
										data-url="/en/products/lyon-canape-lit-4-places-tweed?variant=55108703355260"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Lyon_Kaki_5_-min.jpg?v=1759753645&width=675"
									>
									</div>
								
							
							
							
								
							
						</div>
					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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">
					1 499 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        1 499 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								2 898,00 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-49%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/17924-canape-convertible-3-places-cannes-largeur-180-cm-couchage-140-cm_Kaki_26.jpg?v=1774531316&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/17924-canape-convertible-3-places-cannes-largeur-180-cm-couchage-140-cm_Kaki_26.jpg?v=1774531316&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/17924-canape-convertible-3-places-cannes-largeur-180-cm-couchage-140-cm_Kaki_26.jpg?v=1774531316&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/17924-canape-convertible-3-places-cannes-largeur-180-cm-couchage-140-cm_Kaki_26.jpg?v=1774531316&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/17924-canape-convertible-3-places-cannes-largeur-180-cm-couchage-140-cm_Kaki_26.jpg?v=1774531316&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/17924-canape-convertible-3-places-cannes-largeur-180-cm-couchage-140-cm_Kaki_26.jpg?v=1774531316&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/17924-canape-convertible-3-places-cannes-largeur-180-cm-couchage-140-cm_Kaki_26.jpg?v=1774531316 3115w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/17924-canape-convertible-3-places-cannes-largeur-180-cm-couchage-140-cm_Kaki_26.jpg?v=1774531316&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Kaki"
								class="motion-reduce"
								
								width="3115"
								height="1599"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-CANNES.jpg?v=1774531395&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-CANNES.jpg?v=1774531395&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-CANNES.jpg?v=1774531395&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-CANNES.jpg?v=1774531395&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-CANNES.jpg?v=1774531395&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-CANNES.jpg?v=1774531395&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-CANNES.jpg?v=1774531395 3115w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/AMBIANCE-CANNES.jpg?v=1774531395&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="CANNES - 4 seater convertible sofa - Tweed convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="3115"
									height="1599"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/17928-canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877099061437"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877099061437 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877099061437"
								>
									CANNES - 4 seater convertible sofa - Tweed
								</a>
							</div>
						
						<p class="card__description">Length 200 cm - Bed 160 x 190 cm - Double slatted base </p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877099061437"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
							<div class="card__badge">
								<span
									id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877099061437"
									class="badge badge--bottom-left"
									style="background-color: #000000; color: #ffffff;"
								>
									Braderie
								</span>
							</div>
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-7877099061437"
							
						>
							<a
								href="/en/products/17928-canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877099061437"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877099061437 Badge-template--26281868263804__ax_featured_collections_hdNrga-7877099061437"
							>
								
									CANNES - 4 seater convertible sofa - Tweed
								
							</a> 
						</div>
						
							<p class="card__description">
								
									Length 200 cm - Bed 160 x 190 cm - Double slatted base 
								
							</p>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877099061437"></div>
					</div>

					
						<div class="card__color">
							
								
<div
										class="card__color-item card__color-item--active"
										style="background-color: #355000
 bluish grey"
										data-url="/en/products/17928-canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm?variant=44487856914621"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/17924-canape-convertible-3-places-cannes-largeur-180-cm-couchage-140-cm_Kaki_26.jpg?v=1774531316&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #bfad97"
										data-url="/en/products/17928-canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm?variant=44487856619709"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/17924-canape-convertible-3-places-cannes-largeur-180-cm-couchage-140-cm_Beige_57.jpg?v=1774531395&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #cb852d"
										data-url="/en/products/17928-canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm?variant=44487856652477"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/17924-canape-convertible-3-places-cannes-largeur-180-cm-couchage-140-cm_Moutarde_45.jpg?v=1774531395&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #282a41
 chocolate"
										data-url="/en/products/17928-canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm?variant=44487856685245"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/17924-canape-convertible-3-places-cannes-largeur-180-cm-couchage-140-cm_Bleu_marine_51.jpg?v=1774531395&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #888282"
										data-url="/en/products/17928-canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm?variant=44487856718013"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/17924-canape-convertible-3-places-cannes-largeur-180-cm-couchage-140-cm_Gris_clair_20.jpg?v=1774531395&width=675"
									>
									</div>
								
							
							
							
								
									<div class="card__color-more">
										
										+ 7 colors
									</div>
								
							
						</div>
					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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">
					1 329 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        1 329 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								2 658,00 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-50%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
						<div class="card__badge">
							<span
								id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877099061437"
								class="badge badge--bottom-left"
								style="background-color: #000000; color: #ffffff;"
							>
								Braderie
							</span>
						</div>
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/METZ-ECRU-_6.jpg?v=1767109878&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/METZ-ECRU-_6.jpg?v=1767109878&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/METZ-ECRU-_6.jpg?v=1767109878&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/METZ-ECRU-_6.jpg?v=1767109878&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/METZ-ECRU-_6.jpg?v=1767109878&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/METZ-ECRU-_6.jpg?v=1767109878&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/METZ-ECRU-_6.jpg?v=1767109878 3115w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/METZ-ECRU-_6.jpg?v=1767109878&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Ecru"
								class="motion-reduce"
								
								width="3115"
								height="1599"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/METZ-AMBIANCE.jpg?v=1767109878&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/METZ-AMBIANCE.jpg?v=1767109878&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/METZ-AMBIANCE.jpg?v=1767109878&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/METZ-AMBIANCE.jpg?v=1767109878&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/METZ-AMBIANCE.jpg?v=1767109878&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/METZ-AMBIANCE.jpg?v=1767109878&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/METZ-AMBIANCE.jpg?v=1767109878 3115w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/METZ-AMBIANCE.jpg?v=1767109878&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="METZ 4-seater convertible sofa - Tweed convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="3115"
									height="1599"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/10361-grand-canape-convertible-metz-largeur-200-cm-couchage-quotidien-160-cm"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877005181117"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877005181117 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877005181117"
								>
									METZ 4-seater convertible sofa - Tweed
								</a>
							</div>
						
						<p class="card__description">Length 200 cm - Bed 160 x 190 cm - Double slatted base</p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877005181117"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
							<div class="card__badge">
								<span
									id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877005181117"
									class="badge badge--bottom-left"
									style="background-color: #92b793; color: #ffffff;"
								>
									Top ventes
								</span>
							</div>
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-7877005181117"
							
						>
							<a
								href="/en/products/10361-grand-canape-convertible-metz-largeur-200-cm-couchage-quotidien-160-cm"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877005181117"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877005181117 Badge-template--26281868263804__ax_featured_collections_hdNrga-7877005181117"
							>
								
									METZ 4-seater convertible sofa - Tweed
								
							</a> 
						</div>
						
							<p class="card__description">
								
									Length 200 cm - Bed 160 x 190 cm - Double slatted base
								
							</p>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877005181117"></div>
					</div>

					
						<div class="card__color">
							
								
<div
										class="card__color-item card__color-item--active"
										style="background-color: #e2d7cf"
										data-url="/en/products/10361-grand-canape-convertible-metz-largeur-200-cm-couchage-quotidien-160-cm?variant=44487602176189"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/METZ-ECRU-_6.jpg?v=1767109878&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #282a41
 chocolate"
										data-url="/en/products/10361-grand-canape-convertible-metz-largeur-200-cm-couchage-quotidien-160-cm?variant=44487601914045"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Metz-bleu-marine-_1.jpg?v=1767109878&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #888282"
										data-url="/en/products/10361-grand-canape-convertible-metz-largeur-200-cm-couchage-quotidien-160-cm?variant=44487601946813"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/metz-gris-clair-_2.jpg?v=1767109878&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #494c4a"
										data-url="/en/products/10361-grand-canape-convertible-metz-largeur-200-cm-couchage-quotidien-160-cm?variant=44487601979581"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/METZ-GRIS-SOURIS-_4.jpg?v=1767109878&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #2d2f2e"
										data-url="/en/products/10361-grand-canape-convertible-metz-largeur-200-cm-couchage-quotidien-160-cm?variant=44487602143421"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/METZ-GRIS-ANTHRACITE-_1.jpg?v=1767109878&width=675"
									>
									</div>
								
							
							
							
								
									<div class="card__color-more">
										
										+ 6 colors
									</div>
								
							
						</div>
					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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">
					1 369 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        1 369 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								3 022,16 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-55%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
						<div class="card__badge">
							<span
								id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877005181117"
								class="badge badge--bottom-left"
								style="background-color: #92b793; color: #ffffff;"
							>
								Top ventes
							</span>
						</div>
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/avignon-canape-convertible-3-places-tweed_Vert_sapin_296.jpg?v=1774254819&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/avignon-canape-convertible-3-places-tweed_Vert_sapin_296.jpg?v=1774254819&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/avignon-canape-convertible-3-places-tweed_Vert_sapin_296.jpg?v=1774254819&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/avignon-canape-convertible-3-places-tweed_Vert_sapin_296.jpg?v=1774254819&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/avignon-canape-convertible-3-places-tweed_Vert_sapin_296.jpg?v=1774254819&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/avignon-canape-convertible-3-places-tweed_Vert_sapin_296.jpg?v=1774254819&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/avignon-canape-convertible-3-places-tweed_Vert_sapin_296.jpg?v=1774254819 3115w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/avignon-canape-convertible-3-places-tweed_Vert_sapin_296.jpg?v=1774254819&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Vert sapin"
								class="motion-reduce"
								
								width="3115"
								height="1599"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/avignon-canape-convertible-3-places-tweed_Vert_sapin_297.jpg?v=1774254819&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/avignon-canape-convertible-3-places-tweed_Vert_sapin_297.jpg?v=1774254819&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/avignon-canape-convertible-3-places-tweed_Vert_sapin_297.jpg?v=1774254819&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/avignon-canape-convertible-3-places-tweed_Vert_sapin_297.jpg?v=1774254819&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/avignon-canape-convertible-3-places-tweed_Vert_sapin_297.jpg?v=1774254819&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/avignon-canape-convertible-3-places-tweed_Vert_sapin_297.jpg?v=1774254819&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/avignon-canape-convertible-3-places-tweed_Vert_sapin_297.jpg?v=1774254819 3115w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/avignon-canape-convertible-3-places-tweed_Vert_sapin_297.jpg?v=1774254819&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="#Vert sapin convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="3115"
									height="1599"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/17892-canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877072519357"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877072519357 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877072519357"
								>
									AVIGNON - 4-seater convertible sofa - Tweed
								</a>
							</div>
						
						<p class="card__description">Length 208cm - Bed 160 x 190 cm - Double slatted base - Mattress 16 cm </p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877072519357"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
							<div class="card__badge">
								<span
									id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877072519357"
									class="badge badge--bottom-left"
									style="background-color: #000000; color: #ffffff;"
								>
									Braderie
								</span>
							</div>
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-7877072519357"
							
						>
							<a
								href="/en/products/17892-canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877072519357"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877072519357 Badge-template--26281868263804__ax_featured_collections_hdNrga-7877072519357"
							>
								
									AVIGNON - 4-seater convertible sofa - Tweed
								
							</a> 
						</div>
						
							<p class="card__description">
								
									Length 208cm - Bed 160 x 190 cm - Double slatted base - Mattress 16 cm 
								
							</p>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877072519357"></div>
					</div>

					
						<div class="card__color">
							
								
<div
										class="card__color-item card__color-item--active"
										style="background-color: #2f3b2a"
										data-url="/en/products/17892-canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes?variant=44487788888253"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/avignon-canape-convertible-3-places-tweed_Vert_sapin_296.jpg?v=1774254819&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #8e0109
 mustard"
										data-url="/en/products/17892-canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes?variant=44487788691645"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/avignon-canape-convertible-3-places-tweed_Rouge_304.jpg?v=1774254819&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #888282"
										data-url="/en/products/17892-canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes?variant=44487788724413"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/avignon-canape-convertible-3-places-tweed_Gris_clair_300.jpg?v=1774254819&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #c36a00"
										data-url="/en/products/17892-canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes?variant=44487788757181"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/avignon-canape-convertible-3-places-tweed_Rouille_284.jpg?v=1774254819&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #494c4a"
										data-url="/en/products/17892-canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes?variant=44487788789949"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/avignon-canape-convertible-3-places-tweed_Gris_souris_308.jpg?v=1774254819&width=675"
									>
									</div>
								
							
							
							
								
									<div class="card__color-more">
										
										+ 5 colors
									</div>
								
							
						</div>
					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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">
					1 849 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        1 849 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								3 361,00 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-45%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
						<div class="card__badge">
							<span
								id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877072519357"
								class="badge badge--bottom-left"
								style="background-color: #000000; color: #ffffff;"
							>
								Braderie
							</span>
						</div>
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/Canape-Frejus-C.3-4.jpg?v=1774862421&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/Canape-Frejus-C.3-4.jpg?v=1774862421&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/Canape-Frejus-C.3-4.jpg?v=1774862421&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/Canape-Frejus-C.3-4.jpg?v=1774862421&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/Canape-Frejus-C.3-4.jpg?v=1774862421&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/Canape-Frejus-C.3-4.jpg?v=1774862421&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/Canape-Frejus-C.3-4.jpg?v=1774862421 3115w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/Canape-Frejus-C.3-4.jpg?v=1774862421&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Beige"
								class="motion-reduce"
								
								width="3115"
								height="1599"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/FREJUS.jpg?v=1774263985&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/FREJUS.jpg?v=1774263985&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/FREJUS.jpg?v=1774263985&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/FREJUS.jpg?v=1774263985&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/FREJUS.jpg?v=1774263985&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/FREJUS.jpg?v=1774263985&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/FREJUS.jpg?v=1774263985 3115w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/FREJUS.jpg?v=1774263985&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="FREJUS 3-seater convertible sofa - Bouclette fabric convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="3115"
									height="1599"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/frejus-canape-convertible-4-places-velours"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-15694360904060"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-15694360904060 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-15694360904060"
								>
									FREJUS 3-seater convertible sofa - Bouclette fabric
								</a>
							</div>
						
						<p class="card__description">Length 200 cm - Sleeping area 140 x 190 cm - Double slatted base</p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="15694360904060"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
							<div class="card__badge">
								<span
									id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-15694360904060"
									class="badge badge--bottom-left"
									style="background-color: #92b793; color: #ffffff;"
								>
									Nouveauté
								</span>
							</div>
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-15694360904060"
							
						>
							<a
								href="/en/products/frejus-canape-convertible-4-places-velours"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-15694360904060"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-15694360904060 Badge-template--26281868263804__ax_featured_collections_hdNrga-15694360904060"
							>
								
									FREJUS 3-seater convertible sofa - Bouclette fabric
								
							</a> 
						</div>
						
							<p class="card__description">
								
									Length 200 cm - Sleeping area 140 x 190 cm - Double slatted base
								
							</p>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="15694360904060"></div>
					</div>

					
						<div class="card__color">
							
								
<div
										class="card__color-item card__color-item--active"
										style="background-color: #000"
										data-url="/en/products/frejus-canape-convertible-4-places-velours?variant=55988320502140"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Canape-Frejus-C.3-4.jpg?v=1774862421&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #355000
 bluish grey"
										data-url="/en/products/frejus-canape-convertible-4-places-velours?variant=55945707258236"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Canape-Frejus-C.14-2.jpg?v=1774013136&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #000"
										data-url="/en/products/frejus-canape-convertible-4-places-velours?variant=55988320469372"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Canape-Frejus-C.7-4.jpg?v=1774862488&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #000"
										data-url="/en/products/frejus-canape-convertible-4-places-velours?variant=55945827680636"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Canape-Frejus-C.23-3.jpg?v=1774862421&width=675"
									>
									</div>
								
<div
										class="card__color-item"
										style="background-color: #cb852d"
										data-url="/en/products/frejus-canape-convertible-4-places-velours?variant=55945707291004"
										data-image="//www.convertiblecenter.fr/cdn/shop/files/Canape-Frejus-C.11-4.jpg?v=1774263985&width=675"
									>
									</div>
								
							
							
							
								
									<div class="card__color-more">
										
										+ 7 colors
									</div>
								
							
						</div>
					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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">
					1 999 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        1 999 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								3 331,00 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-40%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
						<div class="card__badge">
							<span
								id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-15694360904060"
								class="badge badge--bottom-left"
								style="background-color: #92b793; color: #ffffff;"
							>
								Nouveauté
							</span>
						</div>
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik.jpg?v=1749025154&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik.jpg?v=1749025154&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik.jpg?v=1749025154&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik.jpg?v=1749025154&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik.jpg?v=1749025154&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik.jpg?v=1749025154&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik.jpg?v=1749025154 2000w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik.jpg?v=1749025154&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Blanc"
								class="motion-reduce"
								
								width="2000"
								height="1497"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_80909fa3-f7c7-404b-bb96-770f3db44fb0.jpg?v=1749025154&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_80909fa3-f7c7-404b-bb96-770f3db44fb0.jpg?v=1749025154&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_80909fa3-f7c7-404b-bb96-770f3db44fb0.jpg?v=1749025154&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_80909fa3-f7c7-404b-bb96-770f3db44fb0.jpg?v=1749025154&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_80909fa3-f7c7-404b-bb96-770f3db44fb0.jpg?v=1749025154&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_80909fa3-f7c7-404b-bb96-770f3db44fb0.jpg?v=1749025154&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_80909fa3-f7c7-404b-bb96-770f3db44fb0.jpg?v=1749025154 2000w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_80909fa3-f7c7-404b-bb96-770f3db44fb0.jpg?v=1749025154&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="#Blanc convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="2000"
									height="1674"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/18061-table-basse-a-plateau-relevable-pratik"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877154865341"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877154865341 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877154865341"
								>
									PRATIK coffee table with lifting top
								</a>
							</div>
						
						<p class="card__description"></p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877154865341"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-7877154865341"
							
						>
							<a
								href="/en/products/18061-table-basse-a-plateau-relevable-pratik"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877154865341"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877154865341 Badge-template--26281868263804__ax_featured_collections_hdNrga-7877154865341"
							>
								
									PRATIK coffee table with lifting top
								
							</a> 
						</div>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877154865341"></div>
					</div>

					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        199 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								398,00 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-50%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
				</div>

				
				
			</div>
		</div>
	</div>
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


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova.jpg?v=1749025175&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova.jpg?v=1749025175&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova.jpg?v=1749025175&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova.jpg?v=1749025175&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova.jpg?v=1749025175&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova.jpg?v=1749025175&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova.jpg?v=1749025175 1800w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova.jpg?v=1749025175&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Blanc"
								class="motion-reduce"
								
								width="1800"
								height="1794"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_1caabc71-c4a0-4118-83ab-74f259c02899.jpg?v=1749025175&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_1caabc71-c4a0-4118-83ab-74f259c02899.jpg?v=1749025175&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_1caabc71-c4a0-4118-83ab-74f259c02899.jpg?v=1749025175&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_1caabc71-c4a0-4118-83ab-74f259c02899.jpg?v=1749025175&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_1caabc71-c4a0-4118-83ab-74f259c02899.jpg?v=1749025175&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_1caabc71-c4a0-4118-83ab-74f259c02899.jpg?v=1749025175&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_1caabc71-c4a0-4118-83ab-74f259c02899.jpg?v=1749025175 1800w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_1caabc71-c4a0-4118-83ab-74f259c02899.jpg?v=1749025175&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="#Blanc convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="1800"
									height="1721"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/18065-table-basse-a-plateau-relevable-plato"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877158371517"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877158371517 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877158371517"
								>
									PLATO lift-top coffee table
								</a>
							</div>
						
						<p class="card__description"></p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877158371517"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-7877158371517"
							
						>
							<a
								href="/en/products/18065-table-basse-a-plateau-relevable-plato"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877158371517"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877158371517 Badge-template--26281868263804__ax_featured_collections_hdNrga-7877158371517"
							>
								
									PLATO lift-top coffee table
								
							</a> 
						</div>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877158371517"></div>
					</div>

					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        199 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								410,96 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-52%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_4dc27eab-35f6-4077-8bc2-d1e1e5de2009.jpg?v=1772535821&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_4dc27eab-35f6-4077-8bc2-d1e1e5de2009.jpg?v=1772535821&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_4dc27eab-35f6-4077-8bc2-d1e1e5de2009.jpg?v=1772535821&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_4dc27eab-35f6-4077-8bc2-d1e1e5de2009.jpg?v=1772535821&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_4dc27eab-35f6-4077-8bc2-d1e1e5de2009.jpg?v=1772535821&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_4dc27eab-35f6-4077-8bc2-d1e1e5de2009.jpg?v=1772535821&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_4dc27eab-35f6-4077-8bc2-d1e1e5de2009.jpg?v=1772535821 2000w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_4dc27eab-35f6-4077-8bc2-d1e1e5de2009.jpg?v=1772535821&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="#Gris clair"
								class="motion-reduce"
								
								width="2000"
								height="1333"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_dcf2103d-6ea5-418e-b190-44ad09d63462.jpg?v=1775034153&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_dcf2103d-6ea5-418e-b190-44ad09d63462.jpg?v=1775034153&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_dcf2103d-6ea5-418e-b190-44ad09d63462.jpg?v=1775034153&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_dcf2103d-6ea5-418e-b190-44ad09d63462.jpg?v=1775034153&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_dcf2103d-6ea5-418e-b190-44ad09d63462.jpg?v=1775034153&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_dcf2103d-6ea5-418e-b190-44ad09d63462.jpg?v=1775034153&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_dcf2103d-6ea5-418e-b190-44ad09d63462.jpg?v=1775034153 2000w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_dcf2103d-6ea5-418e-b190-44ad09d63462.jpg?v=1775034153&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="#Gris clair convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="2000"
									height="1535"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/18066-table-console-extensible-magic"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877158568125"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877158568125 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877158568125"
								>
									MAGIC extendable console table
								</a>
							</div>
						
						<p class="card__description"></p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877158568125"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-7877158568125"
							
						>
							<a
								href="/en/products/18066-table-console-extensible-magic"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877158568125"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877158568125 Badge-template--26281868263804__ax_featured_collections_hdNrga-7877158568125"
							>
								
									MAGIC extendable console table
								
							</a> 
						</div>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877158568125"></div>
					</div>

					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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">
					399 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        399 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								699,00 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-43%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_eb77b57e-3bc9-4fec-b43e-834952ca07c8.jpg?v=1725550543&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_eb77b57e-3bc9-4fec-b43e-834952ca07c8.jpg?v=1725550543&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_eb77b57e-3bc9-4fec-b43e-834952ca07c8.jpg?v=1725550543&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_eb77b57e-3bc9-4fec-b43e-834952ca07c8.jpg?v=1725550543&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_eb77b57e-3bc9-4fec-b43e-834952ca07c8.jpg?v=1725550543&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_eb77b57e-3bc9-4fec-b43e-834952ca07c8.jpg?v=1725550543&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_eb77b57e-3bc9-4fec-b43e-834952ca07c8.jpg?v=1725550543 2000w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_eb77b57e-3bc9-4fec-b43e-834952ca07c8.jpg?v=1725550543&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="Table à manger pliable extensible FACILE"
								class="motion-reduce"
								
								width="2000"
								height="2000"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_349c2952-c93d-4727-a386-ee81d40bb1f9.jpg?v=1725550545&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_349c2952-c93d-4727-a386-ee81d40bb1f9.jpg?v=1725550545&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_349c2952-c93d-4727-a386-ee81d40bb1f9.jpg?v=1725550545&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_349c2952-c93d-4727-a386-ee81d40bb1f9.jpg?v=1725550545&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_349c2952-c93d-4727-a386-ee81d40bb1f9.jpg?v=1725550545&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_349c2952-c93d-4727-a386-ee81d40bb1f9.jpg?v=1725550545&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_349c2952-c93d-4727-a386-ee81d40bb1f9.jpg?v=1725550545 2000w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/table-console-extensible-magic_349c2952-c93d-4727-a386-ee81d40bb1f9.jpg?v=1725550545&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="Table à manger pliable extensible FACILE convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="2000"
									height="2000"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/18067-table-console-extensible-magic"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877159223485"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-7877159223485 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-7877159223485"
								>
									EASY extendable folding dining table
								</a>
							</div>
						
						<p class="card__description"></p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877159223485"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-7877159223485"
							
						>
							<a
								href="/en/products/18067-table-console-extensible-magic"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877159223485"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-7877159223485 Badge-template--26281868263804__ax_featured_collections_hdNrga-7877159223485"
							>
								
									EASY extendable folding dining table
								
							</a> 
						</div>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="7877159223485"></div>
					</div>

					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        199 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								482,17 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-59%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
				</div>

				
				
			</div>
		</div>
	</div>


<div class="card-wrapper product-card-wrapper ">
		<div
			class="
				card card--standard
				 card--media
				
				
				
				
				
			"
			style="--ratio-percent: 60.97560975609756%;"
		>
			<div
				class="card__inner color-scheme-1 gradient ratio"
				style="--ratio-percent: 60.97560975609756%;"
			><div
						class="card__media"
					>
						<div class="media media--transparent media--hover-effect">
							
							<img
								srcset="//www.convertiblecenter.fr/cdn/shop/files/MODUL_1.jpg?v=1753358984&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/MODUL_1.jpg?v=1753358984&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/MODUL_1.jpg?v=1753358984&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/MODUL_1.jpg?v=1753358984&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/MODUL_1.jpg?v=1753358984&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/MODUL_1.jpg?v=1753358984&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/MODUL_1.jpg?v=1753358984 3120w
								"
								src="//www.convertiblecenter.fr/cdn/shop/files/MODUL_1.jpg?v=1753358984&width=800"
								sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
								alt="CHIARA electric lift-up coffee table"
								class="motion-reduce"
								
								width="3120"
								height="1600"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/MODUL_2.jpg?v=1753358984&width=248 165w,//www.convertiblecenter.fr/cdn/shop/files/MODUL_2.jpg?v=1753358984&width=540 360w,//www.convertiblecenter.fr/cdn/shop/files/MODUL_2.jpg?v=1753358984&width=800 533w,//www.convertiblecenter.fr/cdn/shop/files/MODUL_2.jpg?v=1753358984&width=1080 720w,//www.convertiblecenter.fr/cdn/shop/files/MODUL_2.jpg?v=1753358984&width=1410 940w,//www.convertiblecenter.fr/cdn/shop/files/MODUL_2.jpg?v=1753358984&width=1599 1066w,//www.convertiblecenter.fr/cdn/shop/files/MODUL_2.jpg?v=1753358984 3120w
									"
									src="//www.convertiblecenter.fr/cdn/shop/files/MODUL_2.jpg?v=1753358984&width=800"
									sizes="(min-width: 1000px) 750px, (min-width: 990px) calc(((100vw - 60px) / 4) * 3), (min-width: 750px) calc(((100vw - 60px) / 3) * 3), calc(((100vw - 35px) / 2) * 3)"
									alt="CHIARA electric lift-up coffee table convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="3120"
									height="1600"
								></div>
					</div><div class="card__content">
					<div class="card__information">
						
							<div
								class="card__heading"
								
							>
								<a
									href="/en/products/table-basse-a-plateau-relevable-chiara"
									id="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-15465990095228"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--26281868263804__ax_featured_collections_hdNrga-15465990095228 NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-15465990095228"
								>
									CHIARA electric lift-up coffee table
								</a>
							</div>
						
						<p class="card__description">Expandable and electric with battery</p>
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="15465990095228"></div>
					</div>
					
					<div class="card__badges bottom right">
						
						
							<div class="card__badge">
								<span
									id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-15465990095228"
									class="badge badge--bottom-left"
									style="background-color: #92b793; color: #ffffff;"
								>
									Nouveauté
								</span>
							</div>
						
					</div>
				</div>
			</div>
			
			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						<div
							class="card__heading"
							
								id="title-template--26281868263804__ax_featured_collections_hdNrga-15465990095228"
							
						>
							<a
								href="/en/products/table-basse-a-plateau-relevable-chiara"
								id="CardLink-template--26281868263804__ax_featured_collections_hdNrga-15465990095228"
								class="full-unstyled-link"
								aria-labelledby="CardLink-template--26281868263804__ax_featured_collections_hdNrga-15465990095228 Badge-template--26281868263804__ax_featured_collections_hdNrga-15465990095228"
							>
								
									CHIARA electric lift-up coffee table
								
							</a> 
						</div>
						
							<p class="card__description">
								
									Expandable and electric with battery
								
							</p>
						
						<div class="skeepers_product__stars" style="padding-top: 7px;height: 20px;" data-product-id="15465990095228"></div>
					</div>

					
					
					<div class="card-information">

<div
	class="
    price price--large price--on-sale"

>
	<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">
					1 499 €
        </span></div>
		<div class="price__sale">
			<span class="visually-hidden visually-hidden--inline">Sale price</span>
			<span class="price-item price-item--sale price-item--last">
        1 499 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								2 141,00 €
							
						
          </s>
        </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>
		

		

				<span class="badge price__badge-sale color-scheme-06a983db-cea1-4909-8e83-eaeb47b56497">
			
			-30%
    </span>
</div>


						
</div>
				</div>
				
				
				
				<div class="card__badges bottom right">
					
					
						<div class="card__badge">
							<span
								id="NoMediaStandardBadge-template--26281868263804__ax_featured_collections_hdNrga-15465990095228"
								class="badge badge--bottom-left"
								style="background-color: #92b793; color: #ffffff;"
							>
								Nouveauté
							</span>
						</div>
					
				</div>

				
				
			</div>
		</div>
	</div>
Spécialiste du meuble gain de place et du convertible
Specialist in low-priced, quality convertible sofas, CONVERTIBLE CENTER offers a whole range of convertible sofas, sofa beds, convertible armchairs, poufs, fully configurable according to your tastes and needs.
We manufacture custom-made convertible sofas for you, equipped with a robust EXPRESS mechanism guaranteed for 5 years. Choosing CONVERTIBLE CENTER also means benefiting from a wide selection of colors, materials, armrests, mattress qualities, sleeping dimensions, and models!
Our prices? Up to 70% cheaper than elsewhere. No middlemen, manufactured and delivered directly from the factory. Convertible Center is the sofa bed specialist, offering you the best value for money on convertible sofas.
Tips & Tricks
Conseils
Lancement de notre Braderie de Printemps : profitez d’offres exceptionnelles sur nos canapés convertibles
Information
🌼 Results of our fundraising for the Curie Institute: thank you for your commitment
Conseils
Increase your Airbnb income: the convertible sofa, your profitability lever!
Conseils
Optimize space: our tips for integrating a convertible sofa into your living room
Conseils
Express system convertible sofa: the perfect compromise between comfort and practicality
Information
🌼 From March 10th to 22nd, Convertible Center is partnering with the Curie Institute
Nouveau
New 2026 collection: discover the new convertible sofas from Convertible Center
Conseils
How to integrate an express system sofa into different interior design styles?
Conseils
Safety and comfort: is the convertible sofa an ally against falls at home for seniors?
Conseils
Customize your convertible sofa: cushions, throws and accessories for a unique style
Information
Extended offer at Convertible Center: the ideal convertible sofa for your home
Conseils
Mattress for a 140x190 sofa bed, specially formulated for back pain: how to choose the right firmness?
Conseils
Choosing your sofa bed with chaise longue and storage: criteria to know before buying
Conseils
How to choose the right sofa colour trend for 2026 when you have children/pets?
Information
Winter Sale Launches at Convertible Center: the best convertible sofas at exceptional prices ❄️🛋️
Conseils
Sofa trends for 2026: how to choose the perfect model for your space and lifestyle
Conseils
Small convertible corner sofa: the 2-in-1 solution for studios and small spaces
Conseils
Mattress for a 140 x 190 cm sofa bed: what is the minimum thickness for a good night's sleep?
Conseils
Sofa colour trends for 2026: how to combine them with your walls and existing decor?
Conseils
Arranging a small living room with a corner sofa: 7 space-saving configurations
Conseils
What is the purpose of the storage compartment in the chaise longue of a convertible sofa?
Conseils
Sofa color trends for 2026: the 5 star shades to adopt according to your interior style
Conseils
Changing the mattress of your 140 x 190 cm sofa bed: instructions + mistakes to avoid
Newsletter
Subscribe to our newsletter to be notified of new products, special offers and news from Convertible center
Sleeping in the living room is no longer a punishment!
-
Information
- Terms and Conditions
- Legal notices
- Privacy Policy
- Sitemap
Change your cookie preferences here.
Our advantages
Our commitments
Information
- Terms and Conditions
- Legal notices
- Privacy Policy
- Sitemap
Change your cookie preferences here.
©All rights reserved - Convertible Center 2026
We deliver in
We accept
- Choosing a selection results in a full page refresh.
- Opens in a new window.