Our best sellers
Bed 140 cm
Bed 120 cm
Bed 160 cm
Space-saving furniture
TRAPEZE 3-seater convertible sofa - Velvet
Length 200 cm - Sleeping area 140 x 190 cm - Double slatted base
+ 5 colors
Regular price
1 699 €
Sale price
1 699 €
Regular price
2 880,73 €
Unit price
/
per
Nouveauté
Regular price
429 €
Sale price
429 €
Regular price
499,00 €
Unit price
/
per
Nouveauté
MARSEILLE - 3-seater convertible sofa - Tweed
Length 170 cm - Sleeping area 140 x 190 cm - Double slatted base
+ 5 colors
Regular price
1 149 €
Sale price
1 149 €
Regular price
2 431,45 €
Unit price
/
per
Meilleure vente
Auron - 3 seater convertible sofa - Tweed
Length 194cm - sleeping area 140 x 190 cm - Double slatted base
+ 4 colors
Regular price
1 699 €
Sale price
1 699 €
Regular price
2 880,00 €
Unit price
/
per
Nouveauté
SAINT-TROPEZ 3-seater convertible sofa - Velvet - Bed 140 x 190 cm - Width 200 cm
Length 208 cm - Sleeping area 140 x 190 cm - Double slatted base
+ 3 colors
Regular price
1 699 €
Sale price
1 699 €
Regular price
2 880,00 €
Unit price
/
per
Mieux que des soldes
MILANO - 3 seater convertible sofa - Tweed
Length 188 cm - Bed 140 x 190 cm - Double slatted base - Mattress 16 cm
+ 7 colors
Regular price
1 299 €
Sale price
1 299 €
Regular price
2 835,58 €
Unit price
/
per
Matelas 16cm
BEAULIEU - 3-seater convertible sofa - Tweed
Length 170 cm - Bed 140 x 190 cm - Double slatted base
+ 6 colors
Regular price
1 299 €
Sale price
1 299 €
Regular price
3 299,00 €
Unit price
/
per
MANOSQUE - 5-seater convertible corner sofa - Tweed
Length 268 cm - Bed 140 x 190 cm - Double slatted base - Reversible chaise longue
+ 6 colors
Regular price
1 899 €
Sale price
1 899 €
Regular price
4 616,44 €
Unit price
/
per
Meilleure vente

<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-convertible-montpellier-largeur-154-cm-couchage-120-cm_6f1bc637-8e8b-494b-ae4f-18dac3e0d697.jpg?v=1735558713&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-montpellier-largeur-154-cm-couchage-120-cm_6f1bc637-8e8b-494b-ae4f-18dac3e0d697.jpg?v=1735558713&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-montpellier-largeur-154-cm-couchage-120-cm_6f1bc637-8e8b-494b-ae4f-18dac3e0d697.jpg?v=1735558713&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-montpellier-largeur-154-cm-couchage-120-cm_6f1bc637-8e8b-494b-ae4f-18dac3e0d697.jpg?v=1735558713&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-montpellier-largeur-154-cm-couchage-120-cm_6f1bc637-8e8b-494b-ae4f-18dac3e0d697.jpg?v=1735558713&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-montpellier-largeur-154-cm-couchage-120-cm_6f1bc637-8e8b-494b-ae4f-18dac3e0d697.jpg?v=1735558713&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-montpellier-largeur-154-cm-couchage-120-cm_6f1bc637-8e8b-494b-ae4f-18dac3e0d697.jpg?v=1735558713 2066w
                "
								src="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-montpellier-largeur-154-cm-couchage-120-cm_6f1bc637-8e8b-494b-ae4f-18dac3e0d697.jpg?v=1735558713&width=533"
								sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
								alt="#Ecru  "
								class="motion-reduce"
								
								width="2066"
								height="1192"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-montpellier-largeur-154-cm-couchage-120-cm_8f04464c-66f4-472c-bb76-62700434791c.jpg?v=1735558713&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-montpellier-largeur-154-cm-couchage-120-cm_8f04464c-66f4-472c-bb76-62700434791c.jpg?v=1735558713&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-montpellier-largeur-154-cm-couchage-120-cm_8f04464c-66f4-472c-bb76-62700434791c.jpg?v=1735558713&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-montpellier-largeur-154-cm-couchage-120-cm_8f04464c-66f4-472c-bb76-62700434791c.jpg?v=1735558713&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-montpellier-largeur-154-cm-couchage-120-cm_8f04464c-66f4-472c-bb76-62700434791c.jpg?v=1735558713&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-montpellier-largeur-154-cm-couchage-120-cm_8f04464c-66f4-472c-bb76-62700434791c.jpg?v=1735558713&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-montpellier-largeur-154-cm-couchage-120-cm_8f04464c-66f4-472c-bb76-62700434791c.jpg?v=1735558713 1800w
                  "
									src="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-montpellier-largeur-154-cm-couchage-120-cm_8f04464c-66f4-472c-bb76-62700434791c.jpg?v=1735558713&width=533"
									sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
									alt="#Ecru   convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="1800"
									height="1025"
								></div>
					</div></div>

			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						
							
								<a
									href="/en/products/10251-canape-convertible-montpellier-largeur-154-cm-couchage-120-cm"
									id="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-7877004067005"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-7877004067005 NoMediaStandardBadge-template--17287900954813__ax_featured_collections_hdNrga-7877004067005"
								>
									<div
										class="card__heading"
										
									>
									MONTPELLIER - Small 2-seater convertible sofa - Tweed
							</div>

								</a>
						<p class="card__description">Length 154 cm - Sleeping area 120 x 190 cm - Double slatted base</p>
					</div>

					
						<div class="card__color">
<div
									class="card__color-item card__color-item--active"
									style="background-color: #e2d7cf"
									data-url="/en/products/10251-canape-convertible-montpellier-largeur-154-cm-couchage-120-cm?variant=44487595294909"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-montpellier-largeur-154-cm-couchage-120-cm_6f1bc637-8e8b-494b-ae4f-18dac3e0d697.jpg?v=1735558713&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #282a41"
									data-url="/en/products/10251-canape-convertible-montpellier-largeur-154-cm-couchage-120-cm?variant=44487594999997"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-montpellier-largeur-154-cm-couchage-120-cm_6af88899-fc70-49a8-9633-00435c5eb4b4.jpg?v=1735558713&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #888282"
									data-url="/en/products/10251-canape-convertible-montpellier-largeur-154-cm-couchage-120-cm?variant=44487595032765"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-montpellier-largeur-154-cm-couchage-120-cm_d0c5decc-a4c7-43bc-9656-166c02f990ca.jpg?v=1735558713&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #494c4a"
									data-url="/en/products/10251-canape-convertible-montpellier-largeur-154-cm-couchage-120-cm?variant=44487595065533"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-montpellier-largeur-154-cm-couchage-120-cm_8c4c592d-5cdf-4c7a-a570-90acf6a2888c.jpg?v=1735558713&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #0d666a"
									data-url="/en/products/10251-canape-convertible-montpellier-largeur-154-cm-couchage-120-cm?variant=44487595196605"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-montpellier-largeur-154-cm-couchage-120-cm_12298a6e-f578-47ee-bda4-0a1bec653573.jpg?v=1735558713&width=450"
								>

								</div>
							
							
								<div class="card__color-more">
									
									+ 5 colors
								</div>
							
						</div>
					
					<div class="card-information"><span class="caption-large light"></span>










						
<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 029 €
        </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 029 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								2 305,27 €
							
						
          </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">
			
			-56%
    </span>
</div>


						
</div>
				</div>
				
				<div class="card__badges bottom right">
					
					
						<div class="card__badge">
            <span
							id="NoMediaStandardBadge-template--17287900954813__ax_featured_collections_hdNrga-7877004067005"
							class="badge badge--bottom-left"
							style="background-color: #94a595; color: #ffffff;"
						>
              Meilleure vente
            </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-lit-sans-accoudoirs-roubaix-largeur-150-cm-couchage-120-cm_bd02d0c3-1bae-4aba-9266-76eae0bab906.jpg?v=1741248540&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/canape-lit-sans-accoudoirs-roubaix-largeur-150-cm-couchage-120-cm_bd02d0c3-1bae-4aba-9266-76eae0bab906.jpg?v=1741248540&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/canape-lit-sans-accoudoirs-roubaix-largeur-150-cm-couchage-120-cm_bd02d0c3-1bae-4aba-9266-76eae0bab906.jpg?v=1741248540&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/canape-lit-sans-accoudoirs-roubaix-largeur-150-cm-couchage-120-cm_bd02d0c3-1bae-4aba-9266-76eae0bab906.jpg?v=1741248540&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/canape-lit-sans-accoudoirs-roubaix-largeur-150-cm-couchage-120-cm_bd02d0c3-1bae-4aba-9266-76eae0bab906.jpg?v=1741248540&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/canape-lit-sans-accoudoirs-roubaix-largeur-150-cm-couchage-120-cm_bd02d0c3-1bae-4aba-9266-76eae0bab906.jpg?v=1741248540&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/canape-lit-sans-accoudoirs-roubaix-largeur-150-cm-couchage-120-cm_bd02d0c3-1bae-4aba-9266-76eae0bab906.jpg?v=1741248540 3827w
                "
								src="//www.convertiblecenter.fr/cdn/shop/files/canape-lit-sans-accoudoirs-roubaix-largeur-150-cm-couchage-120-cm_bd02d0c3-1bae-4aba-9266-76eae0bab906.jpg?v=1741248540&width=533"
								sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
								alt="#Gris clair"
								class="motion-reduce"
								
								width="3827"
								height="2099"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/canape-lit-sans-accoudoirs-roubaix-largeur-150-cm-couchage-120-cm_b209ee52-5009-432f-824a-73c96f9e9045.jpg?v=1741248540&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/canape-lit-sans-accoudoirs-roubaix-largeur-150-cm-couchage-120-cm_b209ee52-5009-432f-824a-73c96f9e9045.jpg?v=1741248540&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/canape-lit-sans-accoudoirs-roubaix-largeur-150-cm-couchage-120-cm_b209ee52-5009-432f-824a-73c96f9e9045.jpg?v=1741248540&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/canape-lit-sans-accoudoirs-roubaix-largeur-150-cm-couchage-120-cm_b209ee52-5009-432f-824a-73c96f9e9045.jpg?v=1741248540&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/canape-lit-sans-accoudoirs-roubaix-largeur-150-cm-couchage-120-cm_b209ee52-5009-432f-824a-73c96f9e9045.jpg?v=1741248540&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/canape-lit-sans-accoudoirs-roubaix-largeur-150-cm-couchage-120-cm_b209ee52-5009-432f-824a-73c96f9e9045.jpg?v=1741248540&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/canape-lit-sans-accoudoirs-roubaix-largeur-150-cm-couchage-120-cm_b209ee52-5009-432f-824a-73c96f9e9045.jpg?v=1741248540 5008w
                  "
									src="//www.convertiblecenter.fr/cdn/shop/files/canape-lit-sans-accoudoirs-roubaix-largeur-150-cm-couchage-120-cm_b209ee52-5009-432f-824a-73c96f9e9045.jpg?v=1741248540&width=533"
									sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
									alt="#Gris clair convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="5008"
									height="2920"
								></div>
					</div></div>

			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						
							
								<a
									href="/en/products/18057-canape-lit-sans-accoudoirs-roubaix-largeur-150-cm-couchage-120-cm"
									id="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-7877149425853"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-7877149425853 NoMediaStandardBadge-template--17287900954813__ax_featured_collections_hdNrga-7877149425853"
								>
									<div
										class="card__heading"
										
									>
									ROUBAIX - 2-seater sofa bed without armrests - Tweed
							</div>

								</a>
						<p class="card__description">Length 150 cm - Bed 120 x 190 cm - Double slatted base </p>
					</div>

					
						<div class="card__color">
<div
									class="card__color-item card__color-item--active"
									style="background-color: #888282"
									data-url="/en/products/18057-canape-lit-sans-accoudoirs-roubaix-largeur-150-cm-couchage-120-cm?variant=44487994900669"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/canape-lit-sans-accoudoirs-roubaix-largeur-150-cm-couchage-120-cm_bd02d0c3-1bae-4aba-9266-76eae0bab906.jpg?v=1741248540&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #494c4a"
									data-url="/en/products/18057-canape-lit-sans-accoudoirs-roubaix-largeur-150-cm-couchage-120-cm?variant=44487994966205"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/canape-lit-sans-accoudoirs-roubaix-largeur-150-cm-couchage-120-cm_f0fdcf4f-eb39-46e6-be38-84c0dd82041e.jpg?v=1741248540&width=450"
								>

								</div>
							
							
						</div>
					
					<div class="card-information"><span class="caption-large light"></span>










						
<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 099 €
        </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 099 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								2 639,72 €
							
						
          </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 class="card__badge">
            <span
							id="NoMediaStandardBadge-template--17287900954813__ax_featured_collections_hdNrga-7877149425853"
							class="badge badge--bottom-left"
							style="background-color: #dc9f3e; color: #ffffff;"
						>
              Mieux que des soldes
            </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/topi-faut092__ps_01.jpg?v=1744806624&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624 2000w
                "
								src="//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624&width=533"
								sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
								alt="#Gris souris"
								class="motion-reduce"
								
								width="2000"
								height="2000"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624 2000w
                  "
									src="//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624&width=533"
									sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
									alt="#Gris souris convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="2000"
									height="2000"
								></div>
					</div></div>

			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						
							
								<a
									href="/en/products/fauteuil-pivotant-boule"
									id="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-15079291224444"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-15079291224444 NoMediaStandardBadge-template--17287900954813__ax_featured_collections_hdNrga-15079291224444"
								>
									<div
										class="card__heading"
										
									>
									BOULE - Swivel cabriolet armchair - Velvet - chrome or black metal base
							</div>

								</a>
						<p class="card__description"></p>
					</div>

					
						<div class="card__color">
<div
									class="card__color-item card__color-item--active"
									style="background-color: #000"
									data-url="/en/products/fauteuil-pivotant-boule?variant=55009896989052"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #282a41"
									data-url="/en/products/fauteuil-pivotant-boule?variant=55020791005564"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/topi-faut094v__ps_01.jpg?v=1744806624&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #888282"
									data-url="/en/products/fauteuil-pivotant-boule?variant=55009896956284"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/topi-faut074__ps_01.jpg?v=1744806624&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #531920"
									data-url="/en/products/fauteuil-pivotant-boule?variant=55116855312764"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/topi-faut031v__ps_01.jpg?v=1741098241&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #c36a00"
									data-url="/en/products/fauteuil-pivotant-boule?variant=55116855345532"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/topi-faut0710__ps_01.jpg?v=1741098240&width=450"
								>

								</div>
							
							
						</div>
					
					<div class="card-information"><span class="caption-large light"></span>










						
<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">
					429 €
        </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">
        429 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								499,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">
			
			-15%
    </span>
</div>


						
</div>
				</div>
				
				<div class="card__badges bottom right">
					
					
						<div class="card__badge">
            <span
							id="NoMediaStandardBadge-template--17287900954813__ax_featured_collections_hdNrga-15079291224444"
							class="badge badge--bottom-left"
							style="background-color: #94a595; 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/canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm_c6cd77d5-fc5b-437a-aa1e-90b2c3195dc2.jpg?v=1725547771&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm_c6cd77d5-fc5b-437a-aa1e-90b2c3195dc2.jpg?v=1725547771&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm_c6cd77d5-fc5b-437a-aa1e-90b2c3195dc2.jpg?v=1725547771&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm_c6cd77d5-fc5b-437a-aa1e-90b2c3195dc2.jpg?v=1725547771&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm_c6cd77d5-fc5b-437a-aa1e-90b2c3195dc2.jpg?v=1725547771&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm_c6cd77d5-fc5b-437a-aa1e-90b2c3195dc2.jpg?v=1725547771&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm_c6cd77d5-fc5b-437a-aa1e-90b2c3195dc2.jpg?v=1725547771 1800w
                "
								src="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm_c6cd77d5-fc5b-437a-aa1e-90b2c3195dc2.jpg?v=1725547771&width=533"
								sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
								alt="#Ecru  "
								class="motion-reduce"
								
								width="1800"
								height="963"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm_6b3cc16c-6cb5-409c-b523-73b016f0b4ee.jpg?v=1725547776&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm_6b3cc16c-6cb5-409c-b523-73b016f0b4ee.jpg?v=1725547776&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm_6b3cc16c-6cb5-409c-b523-73b016f0b4ee.jpg?v=1725547776&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm_6b3cc16c-6cb5-409c-b523-73b016f0b4ee.jpg?v=1725547776&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm_6b3cc16c-6cb5-409c-b523-73b016f0b4ee.jpg?v=1725547776&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm_6b3cc16c-6cb5-409c-b523-73b016f0b4ee.jpg?v=1725547776&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm_6b3cc16c-6cb5-409c-b523-73b016f0b4ee.jpg?v=1725547776 1800w
                  "
									src="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm_6b3cc16c-6cb5-409c-b523-73b016f0b4ee.jpg?v=1725547776&width=533"
									sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
									alt="#Ecru   convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="1800"
									height="1455"
								></div>
					</div></div>

			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						
							
								<a
									href="/en/products/17932-canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm"
									id="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-7877100830909"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-7877100830909 NoMediaStandardBadge-template--17287900954813__ax_featured_collections_hdNrga-7877100830909"
								>
									<div
										class="card__heading"
										
									>
									VALLAURIS - 2 seater convertible sofa - Tweed
							</div>

								</a>
						<p class="card__description">Length 154 cm - Sleeping area 120 x 190 cm - Double slatted base </p>
					</div>

					
						<div class="card__color">
<div
									class="card__color-item card__color-item--active"
									style="background-color: #bfad97"
									data-url="/en/products/17932-canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm?variant=44487860125885"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm.jpg?v=1725547668&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #cb852d"
									data-url="/en/products/17932-canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm?variant=44487860158653"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm_108450a6-4cfe-40d2-9953-c4991eb8d5a1.jpg?v=1725547690&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #282a41"
									data-url="/en/products/17932-canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm?variant=44487860191421"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm_3196d7a1-c106-45ec-8677-882daec1b17f.jpg?v=1725547703&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #888282"
									data-url="/en/products/17932-canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm?variant=44487860224189"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm_411ef3df-b099-4146-bcda-0f6edbb2aa57.jpg?v=1725547720&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #494c4a"
									data-url="/en/products/17932-canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm?variant=44487860256957"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-vallauris-largeur-152-cm-couchage-120-cm_1831b419-8667-4868-9a9b-a822a2b0602c.jpg?v=1725547736&width=450"
								>

								</div>
							
							
								<div class="card__color-more">
									
									+ 8 colors
								</div>
							
						</div>
					
					<div class="card-information"><span class="caption-large light"></span>










						
<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">
            
							
								3 045,03 €
							
						
          </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">
			
			-61%
    </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/canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges_f27733af-a956-4961-acd5-3bd648861208.jpg?v=1735559236&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges_f27733af-a956-4961-acd5-3bd648861208.jpg?v=1735559236&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges_f27733af-a956-4961-acd5-3bd648861208.jpg?v=1735559236&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges_f27733af-a956-4961-acd5-3bd648861208.jpg?v=1735559236&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges_f27733af-a956-4961-acd5-3bd648861208.jpg?v=1735559236&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges_f27733af-a956-4961-acd5-3bd648861208.jpg?v=1735559236&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges_f27733af-a956-4961-acd5-3bd648861208.jpg?v=1735559236 2140w
                "
								src="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges_f27733af-a956-4961-acd5-3bd648861208.jpg?v=1735559236&width=533"
								sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
								alt="#Ecru"
								class="motion-reduce"
								
								width="2140"
								height="1220"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges_01419d5a-60c4-428a-ac16-dba77df250c4.jpg?v=1735559236&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges_01419d5a-60c4-428a-ac16-dba77df250c4.jpg?v=1735559236&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges_01419d5a-60c4-428a-ac16-dba77df250c4.jpg?v=1735559236&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges_01419d5a-60c4-428a-ac16-dba77df250c4.jpg?v=1735559236&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges_01419d5a-60c4-428a-ac16-dba77df250c4.jpg?v=1735559236&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges_01419d5a-60c4-428a-ac16-dba77df250c4.jpg?v=1735559236&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges_01419d5a-60c4-428a-ac16-dba77df250c4.jpg?v=1735559236 1800w
                  "
									src="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges_01419d5a-60c4-428a-ac16-dba77df250c4.jpg?v=1735559236&width=533"
									sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
									alt="#Ecru convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="1800"
									height="1172"
								></div>
					</div></div>

			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						
							
								<a
									href="/en/products/17716-canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges"
									id="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-7877036966077"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-7877036966077 NoMediaStandardBadge-template--17287900954813__ax_featured_collections_hdNrga-7877036966077"
								>
									<div
										class="card__heading"
										
									>
									MURANO - 2 seater convertible sofa - Tweed
							</div>

								</a>
						<p class="card__description">Length 160 cm - Bed 120 x 190 cm - Double slatted base - Mattress 16 cm </p>
					</div>

					
						<div class="card__color">
<div
									class="card__color-item card__color-item--active"
									style="background-color: #e2d7cf"
									data-url="/en/products/17716-canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges?variant=44487712866493"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges_f27733af-a956-4961-acd5-3bd648861208.jpg?v=1735559236&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #bfad97"
									data-url="/en/products/17716-canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges?variant=44487712571581"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges.jpg?v=1735559236&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #282a41"
									data-url="/en/products/17716-canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges?variant=44487712604349"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges_00550756-0b74-44f4-a88c-b71d530d37b2.jpg?v=1735559236&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #888282"
									data-url="/en/products/17716-canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges?variant=44487712637117"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges_5a4b0a64-7650-40f5-8bb4-eafb69f0484b.jpg?v=1735559236&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #494c4a"
									data-url="/en/products/17716-canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges?variant=44487712669885"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-murano-largeur-160-cm-matelas-16-cm-couchage-120-cm-sommier-doubles-lattes-larges_a75ebb78-ff49-4f59-a55d-923f25623b3a.jpg?v=1735559236&width=450"
								>

								</div>
							
							
								<div class="card__color-more">
									
									+ 6 colors
								</div>
							
						</div>
					
					<div class="card-information"><span class="caption-large light"></span>










						
<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 269 €
        </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 269 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								2 660,18 €
							
						
          </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--17287900954813__ax_featured_collections_hdNrga-7877036966077"
							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/canape-convertible-2-places-piazza-largeur-160cm-couchage-120-cm_56ce86e8-35b3-4dc5-9300-2f597061d955.jpg?v=1725543203&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-piazza-largeur-160cm-couchage-120-cm_56ce86e8-35b3-4dc5-9300-2f597061d955.jpg?v=1725543203&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-piazza-largeur-160cm-couchage-120-cm_56ce86e8-35b3-4dc5-9300-2f597061d955.jpg?v=1725543203&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-piazza-largeur-160cm-couchage-120-cm_56ce86e8-35b3-4dc5-9300-2f597061d955.jpg?v=1725543203&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-piazza-largeur-160cm-couchage-120-cm_56ce86e8-35b3-4dc5-9300-2f597061d955.jpg?v=1725543203&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-piazza-largeur-160cm-couchage-120-cm_56ce86e8-35b3-4dc5-9300-2f597061d955.jpg?v=1725543203&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-piazza-largeur-160cm-couchage-120-cm_56ce86e8-35b3-4dc5-9300-2f597061d955.jpg?v=1725543203 1578w
                "
								src="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-piazza-largeur-160cm-couchage-120-cm_56ce86e8-35b3-4dc5-9300-2f597061d955.jpg?v=1725543203&width=533"
								sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
								alt="PIAZZA - 2-seater convertible sofa - Water-repellent velvet"
								class="motion-reduce"
								
								width="1578"
								height="850"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-piazza-largeur-160cm-couchage-120-cm_d6f4d153-0dee-44b2-ac1b-d64d32d08c94.jpg?v=1725543206&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-piazza-largeur-160cm-couchage-120-cm_d6f4d153-0dee-44b2-ac1b-d64d32d08c94.jpg?v=1725543206&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-piazza-largeur-160cm-couchage-120-cm_d6f4d153-0dee-44b2-ac1b-d64d32d08c94.jpg?v=1725543206&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-piazza-largeur-160cm-couchage-120-cm_d6f4d153-0dee-44b2-ac1b-d64d32d08c94.jpg?v=1725543206&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-piazza-largeur-160cm-couchage-120-cm_d6f4d153-0dee-44b2-ac1b-d64d32d08c94.jpg?v=1725543206&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-piazza-largeur-160cm-couchage-120-cm_d6f4d153-0dee-44b2-ac1b-d64d32d08c94.jpg?v=1725543206&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-piazza-largeur-160cm-couchage-120-cm_d6f4d153-0dee-44b2-ac1b-d64d32d08c94.jpg?v=1725543206 1777w
                  "
									src="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-piazza-largeur-160cm-couchage-120-cm_d6f4d153-0dee-44b2-ac1b-d64d32d08c94.jpg?v=1725543206&width=533"
									sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
									alt="PIAZZA - 2-seater convertible sofa - Water-repellent velvet convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="1777"
									height="1080"
								></div>
					</div></div>

			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						
							
								<a
									href="/en/products/17730-canape-convertible-2-places-piazza-largeur-160cm-couchage-120-cm"
									id="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-7877039325373"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-7877039325373 NoMediaStandardBadge-template--17287900954813__ax_featured_collections_hdNrga-7877039325373"
								>
									<div
										class="card__heading"
										
									>
									PIAZZA - 2-seater convertible sofa - Water-repellent velvet
							</div>

								</a>
						<p class="card__description">Bed 120 x 190 cm - Width 160cm - Double slatted base</p>
					</div>

					
						<div class="card__color">
<div
									class="card__color-item card__color-item--active"
									style="background-color: #888282"
									data-url="/en/products/17730-canape-convertible-2-places-piazza-largeur-160cm-couchage-120-cm?variant=44487720665277"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-2-places-piazza-largeur-160cm-couchage-120-cm_56ce86e8-35b3-4dc5-9300-2f597061d955.jpg?v=1725543203&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #282a41"
									data-url="/en/products/17730-canape-convertible-2-places-piazza-largeur-160cm-couchage-120-cm?variant=44487720698045"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/Piazzabeige_3_90bcf039-0231-4ded-94ec-3f524f6983c3.png?v=1735904040&width=450"
								>

								</div>
							
							
						</div>
					
					<div class="card-information"><span class="caption-large light"></span>










						
<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 883,76 €
							
						
          </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--17287900954813__ax_featured_collections_hdNrga-7877039325373"
							class="badge badge--bottom-left"
							style="background-color: #dc9f3e; color: #ffffff;"
						>
              Mieux que des soldes
            </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=1741363167&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/METZ_ECRU_6.jpg?v=1741363167&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/METZ_ECRU_6.jpg?v=1741363167&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/METZ_ECRU_6.jpg?v=1741363167&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/METZ_ECRU_6.jpg?v=1741363167&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/METZ_ECRU_6.jpg?v=1741363167&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/METZ_ECRU_6.jpg?v=1741363167 3120w
                "
								src="//www.convertiblecenter.fr/cdn/shop/files/METZ_ECRU_6.jpg?v=1741363167&width=533"
								sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
								alt="#Ecru"
								class="motion-reduce"
								
								width="3120"
								height="1602"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/METZ_ECRU_7.jpg?v=1741363167&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/METZ_ECRU_7.jpg?v=1741363167&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/METZ_ECRU_7.jpg?v=1741363167&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/METZ_ECRU_7.jpg?v=1741363167&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/METZ_ECRU_7.jpg?v=1741363167&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/METZ_ECRU_7.jpg?v=1741363167&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/METZ_ECRU_7.jpg?v=1741363167 3120w
                  "
									src="//www.convertiblecenter.fr/cdn/shop/files/METZ_ECRU_7.jpg?v=1741363167&width=533"
									sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
									alt="#Ecru convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="3120"
									height="1602"
								></div>
					</div></div>

			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						
							
								<a
									href="/en/products/10361-grand-canape-convertible-metz-largeur-200-cm-couchage-quotidien-160-cm"
									id="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-7877005181117"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-7877005181117 NoMediaStandardBadge-template--17287900954813__ax_featured_collections_hdNrga-7877005181117"
								>
									<div
										class="card__heading"
										
									>
									METZ - Large 4-seater convertible sofa - Tweed
							</div>

								</a>
						<p class="card__description">Length 200 cm - Bed 160 x 190 cm - Double slatted base</p>
					</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=1741363167&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #282a41"
									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=1741363167&width=450"
								>

								</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=1741363167&width=450"
								>

								</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=1741363167&width=450"
								>

								</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=1741363167&width=450"
								>

								</div>
							
							
								<div class="card__color-more">
									
									+ 5 colors
								</div>
							
						</div>
					
					<div class="card-information"><span class="caption-large light"></span>










						
<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 349 €
        </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 349 €
      </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">
			
			-56%
    </span>
</div>


						
</div>
				</div>
				
				<div class="card__badges bottom right">
					
					
						<div class="card__badge">
            <span
							id="NoMediaStandardBadge-template--17287900954813__ax_featured_collections_hdNrga-7877005181117"
							class="badge badge--bottom-left"
							style="background-color: #94a595; color: #ffffff;"
						>
              Meilleure vente
            </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/LOOP-02-Loop-02_3b897c02-df4a-40cd-8cd7-847ae5ec64aa.png?v=1738925479&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/LOOP-02-Loop-02_3b897c02-df4a-40cd-8cd7-847ae5ec64aa.png?v=1738925479&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/LOOP-02-Loop-02_3b897c02-df4a-40cd-8cd7-847ae5ec64aa.png?v=1738925479&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/LOOP-02-Loop-02_3b897c02-df4a-40cd-8cd7-847ae5ec64aa.png?v=1738925479&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/LOOP-02-Loop-02_3b897c02-df4a-40cd-8cd7-847ae5ec64aa.png?v=1738925479&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/LOOP-02-Loop-02_3b897c02-df4a-40cd-8cd7-847ae5ec64aa.png?v=1738925479&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/LOOP-02-Loop-02_3b897c02-df4a-40cd-8cd7-847ae5ec64aa.png?v=1738925479 3955w
                "
								src="//www.convertiblecenter.fr/cdn/shop/files/LOOP-02-Loop-02_3b897c02-df4a-40cd-8cd7-847ae5ec64aa.png?v=1738925479&width=533"
								sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
								alt="#Ecru"
								class="motion-reduce"
								
								width="3955"
								height="2066"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/LOOP-02-MATTRESS_0a3bb7f1-de82-4d69-a2e9-6d1d5adfe3d7.png?v=1738925479&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/LOOP-02-MATTRESS_0a3bb7f1-de82-4d69-a2e9-6d1d5adfe3d7.png?v=1738925479&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/LOOP-02-MATTRESS_0a3bb7f1-de82-4d69-a2e9-6d1d5adfe3d7.png?v=1738925479&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/LOOP-02-MATTRESS_0a3bb7f1-de82-4d69-a2e9-6d1d5adfe3d7.png?v=1738925479&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/LOOP-02-MATTRESS_0a3bb7f1-de82-4d69-a2e9-6d1d5adfe3d7.png?v=1738925479&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/LOOP-02-MATTRESS_0a3bb7f1-de82-4d69-a2e9-6d1d5adfe3d7.png?v=1738925479&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/LOOP-02-MATTRESS_0a3bb7f1-de82-4d69-a2e9-6d1d5adfe3d7.png?v=1738925479 3955w
                  "
									src="//www.convertiblecenter.fr/cdn/shop/files/LOOP-02-MATTRESS_0a3bb7f1-de82-4d69-a2e9-6d1d5adfe3d7.png?v=1738925479&width=533"
									sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
									alt="#Ecru convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="3955"
									height="2066"
								></div>
					</div></div>

			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						
							
								<a
									href="/en/products/isola-canape-convertible-4-places-tweed"
									id="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-14965334999420"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-14965334999420 NoMediaStandardBadge-template--17287900954813__ax_featured_collections_hdNrga-14965334999420"
								>
									<div
										class="card__heading"
										
									>
									ISOLA - 4-seater convertible sofa - Looped velvet
							</div>

								</a>
						<p class="card__description">Length 230 cm - sleeping area 160 x 190 cm - Double slatted base</p>
					</div>

					
						<div class="card__color">
<div
									class="card__color-item card__color-item--active"
									style="background-color: #e2d7cf"
									data-url="/en/products/isola-canape-convertible-4-places-tweed?variant=54879662408060"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/LOOP-02-Loop-02_3b897c02-df4a-40cd-8cd7-847ae5ec64aa.png?v=1738925479&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #888282"
									data-url="/en/products/isola-canape-convertible-4-places-tweed?variant=54879662604668"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/LOOP-17-Front_2b38b92a-ab5e-4330-894b-8cf4b783837a.png?v=1739440395&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #000"
									data-url="/en/products/isola-canape-convertible-4-places-tweed?variant=54879662539132"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/LOOP-11-Front_c9fe1586-1cdc-42e4-801f-ed73e6b93a88.jpg?v=1739440395&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #c36a00"
									data-url="/en/products/isola-canape-convertible-4-places-tweed?variant=54879662440828"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/LOOP-10-Loop-10_bcc5603f-a3d9-4848-b6c4-71f5ffbe2c04.png?v=1739440395&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #8e0109"
									data-url="/en/products/isola-canape-convertible-4-places-tweed?variant=54879662473596"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/LOOP-09-Front_418af278-cfe1-41bf-ab40-fdaacd8b5477.jpg?v=1739440395&width=450"
								>

								</div>
							
							
								<div class="card__color-more">
									
									+ 4 colors
								</div>
							
						</div>
					
					<div class="card-information"><span class="caption-large light"></span>










						
<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 080,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">
			
			-39%
    </span>
</div>


						
</div>
				</div>
				
				<div class="card__badges bottom right">
					
					
						<div class="card__badge">
            <span
							id="NoMediaStandardBadge-template--17287900954813__ax_featured_collections_hdNrga-14965334999420"
							class="badge badge--bottom-left"
							style="background-color: #94a595; 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/topi-faut092__ps_01.jpg?v=1744806624&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624 2000w
                "
								src="//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624&width=533"
								sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
								alt="#Gris souris"
								class="motion-reduce"
								
								width="2000"
								height="2000"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624 2000w
                  "
									src="//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624&width=533"
									sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
									alt="#Gris souris convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="2000"
									height="2000"
								></div>
					</div></div>

			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						
							
								<a
									href="/en/products/fauteuil-pivotant-boule"
									id="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-15079291224444"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-15079291224444 NoMediaStandardBadge-template--17287900954813__ax_featured_collections_hdNrga-15079291224444"
								>
									<div
										class="card__heading"
										
									>
									BOULE - Swivel cabriolet armchair - Velvet - chrome or black metal base
							</div>

								</a>
						<p class="card__description"></p>
					</div>

					
						<div class="card__color">
<div
									class="card__color-item card__color-item--active"
									style="background-color: #000"
									data-url="/en/products/fauteuil-pivotant-boule?variant=55009896989052"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #282a41"
									data-url="/en/products/fauteuil-pivotant-boule?variant=55020791005564"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/topi-faut094v__ps_01.jpg?v=1744806624&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #888282"
									data-url="/en/products/fauteuil-pivotant-boule?variant=55009896956284"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/topi-faut074__ps_01.jpg?v=1744806624&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #531920"
									data-url="/en/products/fauteuil-pivotant-boule?variant=55116855312764"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/topi-faut031v__ps_01.jpg?v=1741098241&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #c36a00"
									data-url="/en/products/fauteuil-pivotant-boule?variant=55116855345532"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/topi-faut0710__ps_01.jpg?v=1741098240&width=450"
								>

								</div>
							
							
						</div>
					
					<div class="card-information"><span class="caption-large light"></span>










						
<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">
					429 €
        </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">
        429 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								499,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">
			
			-15%
    </span>
</div>


						
</div>
				</div>
				
				<div class="card__badges bottom right">
					
					
						<div class="card__badge">
            <span
							id="NoMediaStandardBadge-template--17287900954813__ax_featured_collections_hdNrga-15079291224444"
							class="badge badge--bottom-left"
							style="background-color: #94a595; 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/canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm.jpg?v=1735559770&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm.jpg?v=1735559770&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm.jpg?v=1735559770&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm.jpg?v=1735559770&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm.jpg?v=1735559770&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm.jpg?v=1735559770&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm.jpg?v=1735559770 1574w
                "
								src="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm.jpg?v=1735559770&width=533"
								sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
								alt="#Beige "
								class="motion-reduce"
								
								width="1574"
								height="813"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm_acec00d7-baa7-4877-94c6-66e47aab4e0e.jpg?v=1735559770&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm_acec00d7-baa7-4877-94c6-66e47aab4e0e.jpg?v=1735559770&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm_acec00d7-baa7-4877-94c6-66e47aab4e0e.jpg?v=1735559770&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm_acec00d7-baa7-4877-94c6-66e47aab4e0e.jpg?v=1735559770&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm_acec00d7-baa7-4877-94c6-66e47aab4e0e.jpg?v=1735559770&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm_acec00d7-baa7-4877-94c6-66e47aab4e0e.jpg?v=1735559770&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm_acec00d7-baa7-4877-94c6-66e47aab4e0e.jpg?v=1735559770 1603w
                  "
									src="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm_acec00d7-baa7-4877-94c6-66e47aab4e0e.jpg?v=1735559770&width=533"
									sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
									alt="#Beige  convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="1603"
									height="965"
								></div>
					</div></div>

			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						
							
								<a
									href="/en/products/17928-canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm"
									id="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-7877099061437"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-7877099061437 NoMediaStandardBadge-template--17287900954813__ax_featured_collections_hdNrga-7877099061437"
								>
									<div
										class="card__heading"
										
									>
									CANNES - 4 seater convertible sofa - Tweed
							</div>

								</a>
						<p class="card__description">Length 200 cm - Bed 160 x 190 cm - Double slatted base </p>
					</div>

					
						<div class="card__color">
<div
									class="card__color-item card__color-item--active"
									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/canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm.jpg?v=1735559770&width=450"
								>

								</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/canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm_6833e06c-5f6d-476a-8e5e-ed31d04be20b.jpg?v=1735559770&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #282a41"
									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/canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm_30ba9f30-2cae-45f8-af23-eb7f913a835a.jpg?v=1735559770&width=450"
								>

								</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/canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm_354da561-e5c1-4e88-afc4-c41c252545ee.jpg?v=1725547634&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #494c4a"
									data-url="/en/products/17928-canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm?variant=44487856750781"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-cannes-largeur-200-cm-couchage-160-cm_232f0c04-dbde-402f-8f18-ac2b944a08eb.jpg?v=1725547654&width=450"
								>

								</div>
							
							
								<div class="card__color-more">
									
									+ 8 colors
								</div>
							
						</div>
					
					<div class="card-information"><span class="caption-large light"></span>










						
<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">
            
							
								3 806,93 €
							
						
          </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">
			
			-61%
    </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/canape-convertible-4-places-gap-couchage-160-x-190-cm-largeur-220-cm_87a8ddef-2a88-4659-b938-628312f59b5e.jpg?v=1744702246&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-gap-couchage-160-x-190-cm-largeur-220-cm_87a8ddef-2a88-4659-b938-628312f59b5e.jpg?v=1744702246&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-gap-couchage-160-x-190-cm-largeur-220-cm_87a8ddef-2a88-4659-b938-628312f59b5e.jpg?v=1744702246&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-gap-couchage-160-x-190-cm-largeur-220-cm_87a8ddef-2a88-4659-b938-628312f59b5e.jpg?v=1744702246&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-gap-couchage-160-x-190-cm-largeur-220-cm_87a8ddef-2a88-4659-b938-628312f59b5e.jpg?v=1744702246&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-gap-couchage-160-x-190-cm-largeur-220-cm_87a8ddef-2a88-4659-b938-628312f59b5e.jpg?v=1744702246&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-gap-couchage-160-x-190-cm-largeur-220-cm_87a8ddef-2a88-4659-b938-628312f59b5e.jpg?v=1744702246 1800w
                "
								src="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-gap-couchage-160-x-190-cm-largeur-220-cm_87a8ddef-2a88-4659-b938-628312f59b5e.jpg?v=1744702246&width=533"
								sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
								alt="#Ecru"
								class="motion-reduce"
								
								width="1800"
								height="888"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-gap-couchage-160-x-190-cm-largeur-220-cm_de43fac6-738a-4074-9ea2-9baf45ef8eaf.jpg?v=1744702246&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-gap-couchage-160-x-190-cm-largeur-220-cm_de43fac6-738a-4074-9ea2-9baf45ef8eaf.jpg?v=1744702246&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-gap-couchage-160-x-190-cm-largeur-220-cm_de43fac6-738a-4074-9ea2-9baf45ef8eaf.jpg?v=1744702246&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-gap-couchage-160-x-190-cm-largeur-220-cm_de43fac6-738a-4074-9ea2-9baf45ef8eaf.jpg?v=1744702246&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-gap-couchage-160-x-190-cm-largeur-220-cm_de43fac6-738a-4074-9ea2-9baf45ef8eaf.jpg?v=1744702246&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-gap-couchage-160-x-190-cm-largeur-220-cm_de43fac6-738a-4074-9ea2-9baf45ef8eaf.jpg?v=1744702246&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-gap-couchage-160-x-190-cm-largeur-220-cm_de43fac6-738a-4074-9ea2-9baf45ef8eaf.jpg?v=1744702246 1800w
                  "
									src="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-gap-couchage-160-x-190-cm-largeur-220-cm_de43fac6-738a-4074-9ea2-9baf45ef8eaf.jpg?v=1744702246&width=533"
									sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
									alt="#Ecru convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="1800"
									height="709"
								></div>
					</div></div>

			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						
							
								<a
									href="/en/products/18086-canape-convertible-4-places-gap-couchage-160-x-190-cm-largeur-220-cm"
									id="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-7877174821053"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-7877174821053 NoMediaStandardBadge-template--17287900954813__ax_featured_collections_hdNrga-7877174821053"
								>
									<div
										class="card__heading"
										
									>
									GAP - 4 seater convertible sofa - Velvet
							</div>

								</a>
						<p class="card__description">Length 223 cm - Sleeping area 160 x 190 cm - Double slatted base</p>
					</div>

					
						<div class="card__color">
<div
									class="card__color-item card__color-item--active"
									style="background-color: #e2d7cf"
									data-url="/en/products/18086-canape-convertible-4-places-gap-couchage-160-x-190-cm-largeur-220-cm?variant=55016211710332"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-gap-couchage-160-x-190-cm-largeur-220-cm_1e369efe-2a0c-470c-8969-7506596af455.jpg?v=1744702246&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #000"
									data-url="/en/products/18086-canape-convertible-4-places-gap-couchage-160-x-190-cm-largeur-220-cm?variant=55115909890428"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/Gapkaki_3.png?v=1744702246&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #bfad97"
									data-url="/en/products/18086-canape-convertible-4-places-gap-couchage-160-x-190-cm-largeur-220-cm?variant=55119256781180"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-gap-couchage-160-x-190-cm-largeur-220-cm_e37f1cfc-70f2-455f-9e4e-2430c38be6e7.jpg?v=1725551374&width=450"
								>

								</div>
							
							
						</div>
					
					<div class="card-information"><span class="caption-large light"></span>










						
<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 728,51 €
							
						
          </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--17287900954813__ax_featured_collections_hdNrga-7877174821053"
							class="badge badge--bottom-left"
							style="background-color: #c9a94d; color: #ffffff;"
						>
              Promotion
            </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-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes_97a5413a-4dda-4997-be80-af36ea5687e4.jpg?v=1725546183&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes_97a5413a-4dda-4997-be80-af36ea5687e4.jpg?v=1725546183&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes_97a5413a-4dda-4997-be80-af36ea5687e4.jpg?v=1725546183&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes_97a5413a-4dda-4997-be80-af36ea5687e4.jpg?v=1725546183&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes_97a5413a-4dda-4997-be80-af36ea5687e4.jpg?v=1725546183&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes_97a5413a-4dda-4997-be80-af36ea5687e4.jpg?v=1725546183&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes_97a5413a-4dda-4997-be80-af36ea5687e4.jpg?v=1725546183 1824w
                "
								src="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes_97a5413a-4dda-4997-be80-af36ea5687e4.jpg?v=1725546183&width=533"
								sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
								alt="#Moutarde "
								class="motion-reduce"
								
								width="1824"
								height="1080"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes_f561e9bb-d132-46c6-a00a-1f441b781b7f.jpg?v=1725546185&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes_f561e9bb-d132-46c6-a00a-1f441b781b7f.jpg?v=1725546185&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes_f561e9bb-d132-46c6-a00a-1f441b781b7f.jpg?v=1725546185&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes_f561e9bb-d132-46c6-a00a-1f441b781b7f.jpg?v=1725546185&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes_f561e9bb-d132-46c6-a00a-1f441b781b7f.jpg?v=1725546185&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes_f561e9bb-d132-46c6-a00a-1f441b781b7f.jpg?v=1725546185&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes_f561e9bb-d132-46c6-a00a-1f441b781b7f.jpg?v=1725546185 1920w
                  "
									src="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes_f561e9bb-d132-46c6-a00a-1f441b781b7f.jpg?v=1725546185&width=533"
									sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
									alt="#Moutarde  convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="1920"
									height="973"
								></div>
					</div></div>

			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						
							
								<a
									href="/en/products/17892-canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes"
									id="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-7877072519357"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-7877072519357 NoMediaStandardBadge-template--17287900954813__ax_featured_collections_hdNrga-7877072519357"
								>
									<div
										class="card__heading"
										
									>
									AVIGNON - 4-seater convertible sofa - Tweed
							</div>

								</a>
						<p class="card__description">Length 208cm - Bed 160 x 190 cm - Double slatted base - Mattress 16 cm </p>
					</div>

					
						<div class="card__color">
<div
									class="card__color-item card__color-item--active"
									style="background-color: #8e0109"
									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/canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes.jpg?v=1725546139&width=450"
								>

								</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/canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes_cf8ac75b-b91c-48e5-9bf1-1d8b194ee5e9.jpg?v=1725546148&width=450"
								>

								</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/canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes_7bd1c14a-eebf-411e-95f5-3ff03c94f3e6.jpg?v=1725546157&width=450"
								>

								</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/canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes_474f2106-7fef-4cf7-859c-e4e603bfa757.jpg?v=1725546165&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #e2d7cf"
									data-url="/en/products/17892-canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes?variant=44487788822717"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/canape-convertible-4-places-avignon-largeur-208-cm-matelas-16cm-couchage-160-cm-sommier-doubles-lattes_7540b081-1774-4f9b-81db-c7f320184e09.jpg?v=1725546174&width=450"
								>

								</div>
							
							
								<div class="card__color-more">
									
									+ 5 colors
								</div>
							
						</div>
					
					<div class="card-information"><span class="caption-large light"></span>










						
<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 867,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/topi-faut092__ps_01.jpg?v=1744806624&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624 2000w
                "
								src="//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624&width=533"
								sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
								alt="#Gris souris"
								class="motion-reduce"
								
								width="2000"
								height="2000"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624 2000w
                  "
									src="//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_02.jpg?v=1744806624&width=533"
									sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
									alt="#Gris souris convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="2000"
									height="2000"
								></div>
					</div></div>

			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						
							
								<a
									href="/en/products/fauteuil-pivotant-boule"
									id="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-15079291224444"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-15079291224444 NoMediaStandardBadge-template--17287900954813__ax_featured_collections_hdNrga-15079291224444"
								>
									<div
										class="card__heading"
										
									>
									BOULE - Swivel cabriolet armchair - Velvet - chrome or black metal base
							</div>

								</a>
						<p class="card__description"></p>
					</div>

					
						<div class="card__color">
<div
									class="card__color-item card__color-item--active"
									style="background-color: #000"
									data-url="/en/products/fauteuil-pivotant-boule?variant=55009896989052"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/topi-faut092__ps_01.jpg?v=1744806624&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #282a41"
									data-url="/en/products/fauteuil-pivotant-boule?variant=55020791005564"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/topi-faut094v__ps_01.jpg?v=1744806624&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #888282"
									data-url="/en/products/fauteuil-pivotant-boule?variant=55009896956284"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/topi-faut074__ps_01.jpg?v=1744806624&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #531920"
									data-url="/en/products/fauteuil-pivotant-boule?variant=55116855312764"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/topi-faut031v__ps_01.jpg?v=1741098241&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #c36a00"
									data-url="/en/products/fauteuil-pivotant-boule?variant=55116855345532"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/topi-faut0710__ps_01.jpg?v=1741098240&width=450"
								>

								</div>
							
							
						</div>
					
					<div class="card-information"><span class="caption-large light"></span>










						
<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">
					429 €
        </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">
        429 €
      </span>
				<span class="visually-hidden visually-hidden--inline">Regular price</span>
				<span>
          <s class="price-item price-item--regular">
            
							
								499,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">
			
			-15%
    </span>
</div>


						
</div>
				</div>
				
				<div class="card__badges bottom right">
					
					
						<div class="card__badge">
            <span
							id="NoMediaStandardBadge-template--17287900954813__ax_featured_collections_hdNrga-15079291224444"
							class="badge badge--bottom-left"
							style="background-color: #94a595; color: #ffffff;"
						>
              Nouveauté
            </span>
						</div>
					
				</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-pratik_e7828e26-5732-45c8-ad68-caf404ec8e9f.jpg?v=1725550386&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_e7828e26-5732-45c8-ad68-caf404ec8e9f.jpg?v=1725550386&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_e7828e26-5732-45c8-ad68-caf404ec8e9f.jpg?v=1725550386&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_e7828e26-5732-45c8-ad68-caf404ec8e9f.jpg?v=1725550386&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_e7828e26-5732-45c8-ad68-caf404ec8e9f.jpg?v=1725550386&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_e7828e26-5732-45c8-ad68-caf404ec8e9f.jpg?v=1725550386&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_e7828e26-5732-45c8-ad68-caf404ec8e9f.jpg?v=1725550386 2000w
                "
								src="//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_e7828e26-5732-45c8-ad68-caf404ec8e9f.jpg?v=1725550386&width=533"
								sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
								alt="#Chêne"
								class="motion-reduce"
								
								width="2000"
								height="1667"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_4b333835-ed42-44c3-a1b1-37d00e604690.jpg?v=1725550389&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_4b333835-ed42-44c3-a1b1-37d00e604690.jpg?v=1725550389&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_4b333835-ed42-44c3-a1b1-37d00e604690.jpg?v=1725550389&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_4b333835-ed42-44c3-a1b1-37d00e604690.jpg?v=1725550389&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_4b333835-ed42-44c3-a1b1-37d00e604690.jpg?v=1725550389&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_4b333835-ed42-44c3-a1b1-37d00e604690.jpg?v=1725550389&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_4b333835-ed42-44c3-a1b1-37d00e604690.jpg?v=1725550389 2000w
                  "
									src="//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_4b333835-ed42-44c3-a1b1-37d00e604690.jpg?v=1725550389&width=533"
									sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
									alt="#Chêne convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="2000"
									height="1667"
								></div>
					</div></div>

			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						
							
								<a
									href="/en/products/18061-table-basse-a-plateau-relevable-pratik"
									id="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-7877154865341"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-7877154865341 NoMediaStandardBadge-template--17287900954813__ax_featured_collections_hdNrga-7877154865341"
								>
									<div
										class="card__heading"
										
									>
									PRATIK coffee table with lifting top
							</div>

								</a>
						<p class="card__description"></p>
					</div>

					
						<div class="card__color">
<div
									class="card__color-item card__color-item--active"
									style="background-color: #f8f8f8"
									data-url="/en/products/18061-table-basse-a-plateau-relevable-pratik?variant=44488009253053"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik.jpg?v=1725550370&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #c29f7b"
									data-url="/en/products/18061-table-basse-a-plateau-relevable-pratik?variant=44488009285821"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-pratik_e7828e26-5732-45c8-ad68-caf404ec8e9f.jpg?v=1725550386&width=450"
								>

								</div>
							
							
						</div>
					
					<div class="card-information"><span class="caption-large light"></span>










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

<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_7d7f97f9-54f5-42b4-bf28-9eb6f7ad925a.jpg?v=1725550508&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_7d7f97f9-54f5-42b4-bf28-9eb6f7ad925a.jpg?v=1725550508&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_7d7f97f9-54f5-42b4-bf28-9eb6f7ad925a.jpg?v=1725550508&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_7d7f97f9-54f5-42b4-bf28-9eb6f7ad925a.jpg?v=1725550508&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_7d7f97f9-54f5-42b4-bf28-9eb6f7ad925a.jpg?v=1725550508&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_7d7f97f9-54f5-42b4-bf28-9eb6f7ad925a.jpg?v=1725550508&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_7d7f97f9-54f5-42b4-bf28-9eb6f7ad925a.jpg?v=1725550508 2000w
                "
								src="//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_7d7f97f9-54f5-42b4-bf28-9eb6f7ad925a.jpg?v=1725550508&width=533"
								sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
								alt="Table basse à plateau relevable PLATO"
								class="motion-reduce"
								
								width="2000"
								height="2000"
							>
							
<img
									srcset="//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_31a3fb3c-ff32-4024-a352-c9726b8fedfc.jpg?v=1725550512&width=165 165w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_31a3fb3c-ff32-4024-a352-c9726b8fedfc.jpg?v=1725550512&width=360 360w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_31a3fb3c-ff32-4024-a352-c9726b8fedfc.jpg?v=1725550512&width=533 533w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_31a3fb3c-ff32-4024-a352-c9726b8fedfc.jpg?v=1725550512&width=720 720w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_31a3fb3c-ff32-4024-a352-c9726b8fedfc.jpg?v=1725550512&width=940 940w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_31a3fb3c-ff32-4024-a352-c9726b8fedfc.jpg?v=1725550512&width=1066 1066w,//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_31a3fb3c-ff32-4024-a352-c9726b8fedfc.jpg?v=1725550512 2000w
                  "
									src="//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_31a3fb3c-ff32-4024-a352-c9726b8fedfc.jpg?v=1725550512&width=533"
									sizes="(min-width: 1600px) 400px, (min-width: 990px) calc((100vw - 60px) / 4), (min-width: 750px) calc((100vw - 60px) / 3), calc((100vw - 35px) / 2)"
									alt="Table basse à plateau relevable PLATO convertiblecenter"
									class="motion-reduce"
									loading="lazy"
									width="2000"
									height="2000"
								></div>
					</div></div>

			<div class="card__content">
				<div class="card__information">
					<div class="card__informations-head">
						
							
								<a
									href="/en/products/18065-table-basse-a-plateau-relevable-plato"
									id="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-7877158371517"
									class="full-unstyled-link"
									aria-labelledby="StandardCardNoMediaLink-template--17287900954813__ax_featured_collections_hdNrga-7877158371517 NoMediaStandardBadge-template--17287900954813__ax_featured_collections_hdNrga-7877158371517"
								>
									<div
										class="card__heading"
										
									>
									PLATO lift-top coffee table
							</div>

								</a>
						<p class="card__description"></p>
					</div>

					
						<div class="card__color">
<div
									class="card__color-item card__color-item--active"
									style="background-color: #f8f8f8"
									data-url="/en/products/18065-table-basse-a-plateau-relevable-plato?variant=44488017346749"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova.jpg?v=1725550500&width=450"
								>

								</div>
							
<div
									class="card__color-item"
									style="background-color: #c29f7b"
									data-url="/en/products/18065-table-basse-a-plateau-relevable-plato?variant=44488017379517"
									data-image="//www.convertiblecenter.fr/cdn/shop/files/table-basse-a-plateau-relevable-nova_7d7f97f9-54f5-42b4-bf28-9eb6f7ad925a.jpg?v=1725550508&width=450"
								>

								</div>
							
							
						</div>
					
					<div class="card-information"><span class="caption-large light"></span>










						
<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>
Specialist in space-saving furniture and convertibles
Specialist in high quality convertible sofas at low prices and quality, CONVERTIBLE CENTER offers you a whole range of convertible sofas, sofa beds, convertible armchairs, poufs, fully configurable according to your tastes and needs. We manufacture for you a custom-made convertible sofa, equipped with a solid EXPRESS mechanism guaranteed for 5 years.
Trusting CONVERTIBLE CENTER also means benefiting from a wide choice of colors, materials, armrests, mattress quality, sleeping dimensions and models!
Our prices? Up to 70% cheaper than elsewhere. Without intermediaries, manufactured and delivered directly from the factory. Convertible Center is the sofa bed specialist to offer you the best quality/price ratio in terms of convertible sofas.
Cozy atmosphere
Cozy atmosphere
From everyday life to special moments with friends, our sofas are ready for every moment. Designed to fit your lifestyle, whether it’s for everyday use, a holiday home or entertaining guests, our sofa beds offer a perfect combination of comfort and functionality.
From everyday life to special moments with friends, our sofas are ready for every moment. Designed to fit your lifestyle, whether it’s for everyday use, a holiday home or entertaining guests, our sofa beds offer a perfect combination of comfort and functionality.
Tips & Tricks
Information
Bonne nouvelle : Convertible Center livre désormais en Suisse romande !
