Test: Cupra Born vs BYD Atto 3 – lika som päron


<h3 class="wp-block-heading">Båda har en angiven räckvidd på 420 km. Båda har varsin elmotor som, för det mesta, levererar 150 kW. Båda kostar 519 000 kronor. Och båda har fiskfjällsmönster på C-stolparna! Det ska ändå visa sig att det är de avsevärda skillnader bilarna emellan som låter en avgå med jordskredsseger.</h3>



<p>BYD och Cupra sa du? Om jag hade kunnat skicka ett sms till mitt fem år yngre jag och berätta att detta var namn på bilmärken som skulle testas 2023 – då hade mitt yngre jag säkert sett ut som ett frågetecken. Men faktum är att för drygt fem år sedan, i februari 2018, presenterades Cupra som ett nytt märke avknoppat från Seat. Tidigare var Cupra benämningen på de allra sportigaste Seat-modellerna.&nbsp;<div id="elbilen_panorama-1"></div><script>lwhb.cmd.push(function() {lwhb.loadAd({tagId: "elbilen_panorama-1"});});</script><div id="elbilen_mobil-1"></div><script>lwhb.cmd.push(function() {lwhb.loadAd({tagId: "elbilen_mobil-1"});});</script></p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/04/Cupra_medak_001.jpg"><img src="https://elbilen.se/wp-content/uploads/2023/04/Cupra_medak_001-1030x687.jpg" alt="" class="wp-image-25650"/></a><figcaption class="wp-element-caption">Inte som din grannes VW ID 3. Born har högre mittkonsol. Sportigt! Materialvalen kändes bra till när ID 3 nyss uppdaterades. Born lär få sin makeover under 2023.&nbsp;<br></figcaption></figure>



<p>Backar vi ytterligare tio år kommer vi till 2008, alltså då BYD presenterade sin första personbil i Kina. Bolaget bildades redan 1995, som producent av bland annat kommersiella fordon och batterier. Deras bussar har rullat på svensk mark sedan 2015.&nbsp;</p>



<p>I fjol var det bara Tesla som producerade fler elbilar än BYD. Tar vi med laddhybrider i ekvationen var BYD med råge världens största producent av elektrifierade personbilar 2022.&nbsp;</p>



<p>Atto 3 må klinga asiatiskt men på hemmamarknaden heter modellen Yuan Plus. Det europeiska namnet kommer från attosekund, en miljarddel av en miljarddels sekund.&nbsp;</p>



<p>Förstod du? Nej okej, låt mig förtydliga: som jämförelse är en attosekund för en sekund vad en sekund är för cirka 31,71 miljarder år.&nbsp;</p>



<p>Vad siffran 3 står för är oklart, det finns inga Atto 1 och 2 &#8230;</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/04/BYD_medak_001.jpg"><img src="https://elbilen.se/wp-content/uploads/2023/04/BYD_medak_001-1030x687.jpg" alt="" class="wp-image-25656"/></a><figcaption class="wp-element-caption">Lekfullheten och materialvalen gillas. Mer längdjustering på ratten önskas. Fysiska knappar, trots jätteskärm, på mittkonsol synas&#8230;<br></figcaption></figure>



<p>Cupra Born visades som konceptbil 2019, då som Seat el-Born – vilket ju faktiskt var ännu roligare på svenska än spanska.</p>



<p>Att BYD har valt att skriva ut förkortningen (Build Your Dreams) på bakluckan är nästan lika osannolikt som att BMW skulle skriva ut Bayerische Motoren Werke.&nbsp;</p>



<p>Utan detta kännetecken hade Atto 3 kunnat vara precis vad som helst. Designen är på intet sätt störande, snarare generiskt intetsägande. Ungefär som bilen i reklam för däck, vax eller extraljus. Den som av rättighetsskäl är en fantasi, men ändå bekant.</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/04/BYD_pan_003.jpg"><img src="https://elbilen.se/wp-content/uploads/2023/04/BYD_pan_003-1030x687.jpg" alt="" class="wp-image-25655"/></a><figcaption class="wp-element-caption">De tredimensionella fiskfjällen på C-stolparna är en visuell likhet mellan bilarna. Att Atto 3 är framhjulsdriven och Born bakhjulsdriven syns ej.</figcaption></figure>



<p>Interiören är betydligt mer originell, i allt från fläktutblås till resårsträngarna som skapar förvaringsfack i dörrarna. Musikaliska chefredaktörs-Fredrik förklarar att de är felstämda. Jag som är mer praktiskt lagd märker att strängarnas fästen inte är riktiga torx, utan plast &#8230; Ooops!</p>



<p>Högtalarna/öppningshandtagen är skoj, precis som den dolda mysbelysningen och den enorma roterande pekskärmen (15,6 tum för utrustningsnivå Design och 12,8 tum för Active och Comfort).</p>



<p>Men när vi börjar använda menysystemet byts upprymdhet mot frustration och förvirring.&nbsp;</p>



<p>Atto 3 har uppdaterats sedan senast vi körde den sist och klarar nu Android Auto samt Apple Car Play. Dock ej trådlöst som i Born.</p>



<figure class="wp-block-gallery has-nested-images columns-default is-cropped wp-block-gallery-1 is-layout-flex wp-block-gallery-is-layout-flex">
<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/04/Detalj__008.jpg"><img data-id="25642" src="https://elbilen.se/wp-content/uploads/2023/04/Detalj__008-1030x687.jpg" alt="" class="wp-image-25642"/></a><figcaption class="wp-element-caption">Världens största bilmärkesemblem!<br> De smutssamlande bokstäverna går att ta bort &#8230;</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/04/Detalj__005.jpg"><img data-id="25645" src="https://elbilen.se/wp-content/uploads/2023/04/Detalj__005-1030x687.jpg" alt="" class="wp-image-25645"/></a><figcaption class="wp-element-caption">Småbarns-föräldrar vill nog även ta bort gitarrsträngarna.</figcaption></figure>
</figure>



<p></p>



<p>Den enorma skärmen till trots tillåts Car Play ta hela skärmen. Vill du ändra någon bilinställning, låt säga temperatur eller sätesvärme, måste du först hitta symbolen för BYD i Car Play för att komma till bilens egna menyer. Väl där återstår ett flertal tryck för att nå en basal sätesvärme.&nbsp;</p>



<p>Precis som sist immar rutorna igen. Till slut märker vi att fläkten går på recirkulation, trots att vi inte har valt det. Efter en djupdykning i menyn hittar vi förklaringen: ”Auto air recirculation” är aktiverat, ett system som ser till att recirkulation inträder vid varje start, men även när bilen saktar ner. Vem önskar sig ens något så urbota dumt?</p>



<p>Vi är på väg till Karlstad, jag och Fredrik, för att genomföra hans snart patenterade räckviddstest. Det är snorkallt, -15 när jag åker till snabbladdaren där vi laddar fullt och startar mätningen.&nbsp;</p>


<div class="wp-block-image">
<figure class="alignleft size-medium"><a href="https://elbilen.se/wp-content/uploads/2023/04/Skarm_002.jpg"><img src="https://elbilen.se/wp-content/uploads/2023/04/Skarm_002-300x300.jpg" alt="" class="wp-image-25700"/></a><figcaption class="wp-element-caption">Roterande skärm har även Fisker Ocean. Synd att Apple Car Play hamnar 90 grader fel vid stående display.</figcaption></figure></div>


<p>Jag har kört en timme för att komma till mötesplatsen, nu är det -5 och snabbladdaren (150 kW) förmår bara mata Atto 3 med 30 kW – trots att batteriets intelligenta temperaturreglering säger sig jobba.</p>



<p>Fulladdat! Räckvidd: 420 km. Detta oavsett om du kör i Eco, Comfort eller Sport (räckviddstest gör vi alltid i grundläget, i det här fallet Comfort) och oavsett yttertemperatur. Bilen har med andra ord ingen färddator, här visas bara wltp-siffran. Någon mil efter avfärd menar Atto 3 att den har 120 km längre räckvidd än Born, helt ologiskt.</p>



<p>Klimatanläggningen i Born står på 21 grader. De sportiga stolarna med fint sidostöd och utdragbart lårstöd är en fröjd att färdas i. Släktdragen med VW ID 3 märks men Born har en högre mittkonsol för en sportigare och mer ombonad känsla.</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/04/Cupra_pan_006.jpg"><img src="https://elbilen.se/wp-content/uploads/2023/04/Cupra_pan_006-1030x687.jpg" alt="" class="wp-image-25649"/></a><figcaption class="wp-element-caption">Cupra Born har svarta fiskfjäll på C-stolparna, grafitgrå backspeglar, kopparfärgade detaljer.<br>I kombination med speciallacken Aurora Blue (11 400 kr) blir det riktigt smakfullt.</figcaption></figure>



<p>Klimatanläggningen i Atto 3 visar 23, ibland 24 grader. Det är en bit under 20 i kupén.</p>



<p>Stolen är kort och kan inte höjdjusteras i framkant. Man sitter högt och ratten går inte att ställa tillräckligt långt i längdled, varför man tvingas sitta längre fram än önskvärt.</p>



<p>Båda bilar har digitalt kombiinstrument rakt framför ratten. Här vinner Born storleksfajten, och dessutom finns head up-display med AR, förstärkt verklighet, som tillval!&nbsp;</p>



<p>Den lilla skärmen i Atto 3 är rejält plottrig. Bilen läser av hastighetsskyltar (eller använder gps-data) och farthållaren kan anpassa till rådande hastighet.</p>



<p>I 99 fall av 100 har den fel, 70 på motorväg och 40 på landsväg. Eller ännu värre, 80 på 50-sträckor. Kopplingen till farthållaren går alltså inte att använda, ej heller visningen eftersom visad hastighet i kombiinstrumentet konstant blinkar ilsket i tron att du är en fartdåre. &nbsp;</p>



<p>Born har en förstklassig rullkomfort. Testbilen har det givna tillvalet DCC, ställbara stötdämpare, som kan ge allt från fluffig gång till … något stramare.&nbsp; Sportbilsväghållning blir det aldrig, bilens höjd går inte att trolla bort.&nbsp;</p>



<figure class="wp-block-gallery has-nested-images columns-default is-cropped wp-block-gallery-2 is-layout-flex wp-block-gallery-is-layout-flex">
<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/04/Detalj__006.jpg"><img data-id="25644" src="https://elbilen.se/wp-content/uploads/2023/04/Detalj__006-1030x687.jpg" alt="" class="wp-image-25644"/></a><figcaption class="wp-element-caption">Enorm vinge till trots blir Borns bakruta smutsig. Vingen är i vägen när mackens fönstertvättsvamp på skaft ska användas.</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/04/Detalj__007.jpg"><img data-id="25643" src="https://elbilen.se/wp-content/uploads/2023/04/Detalj__007-1030x687.jpg" alt="" class="wp-image-25643"/></a><figcaption class="wp-element-caption">Föredömligt med spolning av backkameran!</figcaption></figure>
</figure>



<p></p>



<p>Atto 3 har endast ett chassiläge, och det är stramt. Speciellt tvärskarvar signaleras tydligt från bakvagnen. Hård fjädring på en suv-hög bil inger inte det största av förtroenden vid forcerad kurvtagning. Speciellt i kombination med en riktigt snabb styrutväxling. Båda bilar rullar på friktionsdäck, vilket sänker styrkänslan – men Atto 3 lyckas betydligt sämre än Born när det kommer till att förmedla information om underlaget via ratten. En del av besvikelsen kan skyllas på däckvalet, Kumho, som ofta intar jumboplatserna i test. Cupra rullar på Nokian.</p>



<p>Båda bilar har filhållningsassistent. Tyvärr kommer nog de som lyckas hitta rätt i menyn att stänga av systemet i Atto 3 . För när den tillåts pipa och/eller vibrera i ratten är det ett konstant larmande, trots precisionskörning mitt i körfältet.&nbsp;</p>



<p>Bilduon passerar Örebro och BYD är alltjämt betydligt kaxigare än Cupra avseende återstående räckvidd i kilometer. I batteriprocent är det betydligt jämnare och vi inser att kylan gör det omöjligt att nå Karlstad i annat än snigeltempo sista biten.&nbsp;</p>



<figure class="wp-block-gallery has-nested-images columns-default is-cropped wp-block-gallery-3 is-layout-flex wp-block-gallery-is-layout-flex">
<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/04/Detalj__002.jpg"><img data-id="25647" src="https://elbilen.se/wp-content/uploads/2023/04/Detalj__002-1030x687.jpg" alt="" class="wp-image-25647"/></a><figcaption class="wp-element-caption">Elmotorn ligger djupt men BYD har ingen frunk. </figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/04/Detalj__003.jpg"><img data-id="25646" src="https://elbilen.se/wp-content/uploads/2023/04/Detalj__003-1030x687.jpg" alt="" class="wp-image-25646"/></a><figcaption class="wp-element-caption">Mer skydd och isolering som hos Born känns önskvärt.</figcaption></figure>
</figure>



<p></p>



<p>Det blir laddning i Kristinehamn i&nbsp;stället, där Atto 3 besöker tre laddstolpar innan den vill samarbeta. (Se Fredriks separata text om batteriteknik och laddkurvor, här konstaterar vi kort att Atto 3 otippat tar hem laddronden.)</p>



<p>Båda har sina laddluckor på högersidan, framflygel (BYD) respektive bakflygel. Båda har också nyckellösa system för dörröppning, Atto 3 endast på förardörren. Det gör att du ändå måste ta fram nyckeln för att kunna öppna laddluckan/ta loss laddhandsken, utan att behöva gå runt bilen två gånger.</p>



<p>Atto 3 är en av ytterst få bilar där det inte går att väcka pekskärmen eller slå på ”tändningen” utan en fot på bromsen, vilket alltså startar alla system. Normalt startas skärmar och menyer av en dörröppning, men inte i Atto 3. Såklart &#8230;</p>



<p>Born har visserligen en startknapp på rattstången, men normalt räcker det med att sätta sig i eller gå ur stolen för att väcka bilen. Smidigt!&nbsp;</p>



<p>Den som önskar ökad energiåtervinning vid gasuppsläpp väljer läge B på växelväljaren i Born. Det ger inte enpedalskörning, men nästan. Dessutom finns Eco-Assist som sänker farten ytterligare (ökar återvinningen) när föraren har släppt gasen och närmar sig korsningar, rondeller, område med lägre hastighet samt framförvarande bil. Extremt smidigt – så länge man är medveten om att föraren måste komplettera med viss fotbroms i slutskedet av fartsänkningen.</p>



<p>Atto 3 kräver ett gäng klick på skärmen innan hög energiåtervinning kan aktiveras. Det är klick gjorda förgäves, ty någon skillnad märks inte.</p>



<figure class="wp-block-gallery has-nested-images columns-default is-cropped wp-block-gallery-4 is-layout-flex wp-block-gallery-is-layout-flex">
<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/04/Bagage__001.jpg"><img data-id="25654" src="https://elbilen.se/wp-content/uploads/2023/04/Bagage__001-1030x687.jpg" alt="" class="wp-image-25654"/></a><figcaption class="wp-element-caption">Dubbla lastgolv (tillval Born) hos<br> båda men bara Born har skidlucka.</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/04/Bagage__002.jpg"><img data-id="25653" src="https://elbilen.se/wp-content/uploads/2023/04/Bagage__002-1030x687.jpg" alt="" class="wp-image-25653"/></a></figure>
</figure>



<p></p>



<p>Våra blickar vänds till bagageutrymmena. Den eldrivna bakluckan på Atto 3 kan tyckas smidig. Problemet är att det tar närmare två sekunder från att du tryckt på det dolda öppningshandtaget till att luckan reagerar. Det gör att du trycker en gång till – och stänger … Mätt i vda-litrar sväljer Atto 3 mest, men den är grundare under insynsskyddet när båda bilar har sina i höjd ställbara lastgolv (tillval på Cupra) i respektive högsta lägen. Ryggstöd fälles 60/40, men Born har även genomlastningslucka.</p>



<p>Bli nu inte förvånad, men det är faktiskt Born som ståtar med bekvämast baksäte. Sittdynan är längre och ger bättre lårstöd. Till komfort hör också kupéljud och Born är den tystare, med betydligt lägre nivå för både väg- och vindljud.</p>



<figure class="wp-block-gallery has-nested-images columns-default is-cropped wp-block-gallery-5 is-layout-flex wp-block-gallery-is-layout-flex">
<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/04/Baksate__001.jpg"><img data-id="25652" src="https://elbilen.se/wp-content/uploads/2023/04/Baksate__001-686x1030.jpg" alt="" class="wp-image-25652"/></a><figcaption class="wp-element-caption">Born: Bra plats trots glastak (11 300 kronor). Fint lårstöd.</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/04/Baksate__002.jpg"><img data-id="25651" src="https://elbilen.se/wp-content/uploads/2023/04/Baksate__002-686x1030.jpg" alt="" class="wp-image-25651"/></a><figcaption class="wp-element-caption">Atto 3: Sämre lårstöd, sittställning och utrymme.<br>Stort glastak (standard)</figcaption></figure>
</figure>



<p></p>



<p>Som du har listat ut vid det här laget är det inte mycket som talar för Atto 3. Det kan förvåna då man beaktar att BYD var världens största tillverkare av elfordon i fjol. Av likheterna som nämndes i ingressen var några framtagna med justering av sanningen.&nbsp;</p>



<p>Samma räckvidd enligt WLTP är korrekt. Men för att båda ska kosta 519 000 kronor måste Born förses med eBoost som ger 170 kW i stället för grundversionens 150 kW. Detta dock endast vid extremt sällsynta tillfällen (över en handfull parametrar kring temperatur och batteristatus måste uppfyllas) och i maximalt 30 sekunder.&nbsp;</p>



<p>För Atto 3 Design är sagda summa ett kampanjpris. Ordinarie pris, 554 900 kronor, är förhoppningsvis något som aldrig kommer förverkligas. Det behövs snarare ett ännu lägre kampanjpris för att göra Atto 3 ens värd att överväga. </p>



<p><strong>Fredriks synpunkter:</strong></p>



<p>Jag har sett fram emot BYD:s intåg på svensk mark sedan 2008, då deras eldrivna modell E6 visades upp i Kina. Den lovade gott. Bolaget drevs då som nu av Wang Chuanfu, som var lite av en rockstjärna i elbilssvängen då han likt Tesla-gänget kom från batterisidan. Han var känd för att ha druckit elektrolyt i direktsändning för att visa hur ofarlig den var. BYD har vad många andra bilföretag inte har: egen batteritillverkning. Dessutom av litium-järn-fosfat-batterier – järnbaserade billiga batterier utan vare sig nickel eller kobolt – som man visat kan ge elbilar bra räckvidd, trots sin lägre energitäthet i cellerna. Det är faktiskt 2 kWh mer energi i Atto 3 än i Cupra Born.&nbsp;</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/04/Uppst__011.jpg"><img src="https://elbilen.se/wp-content/uploads/2023/04/Uppst__011-1030x687.jpg" alt="" class="wp-image-25638"/></a></figure>



<p>Den sinnrika lösningen kallas blade-batterier. Batterierna ligger&nbsp;tätt packade som långa svärd, och har inte traditionella batterimoduler. Järnfosfatbatterier kräver inte lika mycket kylning. Men även om batteripackets storlek inte påverkar bilens innerutrymmen väger de dock mer. Batteripacket i Atto 3 väger in på 450 kilo, medan Cuprans batteripack väger 232 kilo. Då måste ju Atto 3 vara mycket tyngre? Det är den inte. Den har en tjänstevikt på 1 825 kilo (basmodell). Cuprans tjänstevikt är 1 834 kg (basmodell). Cupran är alltså tyngre. Och mindre i storlek!</p>



<p>Det märkliga är i det här sammanhanget är att Atto 3 är dyrare än Cupra Born. Med blade-batterierna, alltså de som är järnbaserade, borde den inte kosta över en halv miljon. Elbilens dyraste komponent är ju här en betydligt enklare historia än vad man hittar i Cupra Borns batteripack. En fördel som man ska ha med sig är dock att BYD:s järnbatterier ska vara säkrare och hålla längre än de nickel-baserade katoderna i Cupran. Men det är en klen tröst.&nbsp;</p>



<p>Vad gäller laddning imponeras vi av att den ändå lägger sig strax på maxladdning även i kylig temperatur. Visst borde det vara bättre. Den laddar max med 88 kW. Men Cupran säckade ihop och bjöd på en trött laddupplevelse. På sommaren lär Cupra Born bjuda på en raskare laddning än Atto 3.&nbsp;</p>



<p>Atto 3 är baserad på BYD:s första elbilsplattform, som ska ge bilar med 800 volt och ta tillvara möjligheterna en elbil har i form av större innerutrymmen. Men Atto 3 var ingen bra start, återstår att se vad framtida modeller bjuder på.&nbsp;</p>



<h4 class="wp-block-heading">Fakta om bilarna</h4>



<figure class="wp-block-table is-style-stripes"><table><tbody><tr><td>Märke</td><td><strong>BYD Atto 3 Design</strong></td><td><strong>CupraBorn e-Boost 58</strong></td></tr><tr><td>Pris</td><td>519 700 kr</td><td>519 300</td></tr><tr><td>Batterikapacitet</td><td>60 kWh netto</td><td>58 kWh netto</td></tr><tr><td>Deklarerad räckvidd</td><td>420 km (WLTP)</td><td>420 km (WLTP)</td></tr><tr><td>Snabbladdning</td><td>88 kW</td><td>120 kW</td></tr><tr><td>Ombordladdning</td><td>11 kW</td><td>11 kW</td></tr><tr><td>Drivning</td><td>Framhjulsdrift</td><td>Bakhjulsdrift</td></tr><tr><td>Max motoreffekt / vridmoment</td><td>150 kW / 310 Nm</td><td>150 kW / 310 Nm</td></tr><tr><td>Acceleration 0-100 km/h</td><td>7,3 sek</td><td>7,3 sek</td></tr><tr><td>Topphastighet</td><td>160 km/h</td><td>160 km/h</td></tr><tr><td>Antal platser</td><td>5</td><td>5</td></tr><tr><td>Tjänstevikt</td><td>1 825 kg</td><td>1 856 kg</td></tr><tr><td>Bagageutrymme</td><td>440 liter</td><td>385 liter</td></tr><tr><td>Dragvikt</td><td>0</td><td>0</td></tr><tr><td>Batterigaranti</td><td>8 år / 16 000 mil</td><td>8 år / 16 000 mil</td></tr></tbody></table></figure>



<h4 class="wp-block-heading">Laddkurvor</h4>



<figure class="wp-block-gallery has-nested-images columns-default is-cropped wp-block-gallery-6 is-layout-flex wp-block-gallery-is-layout-flex">
<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/04/Skarmavbild-2023-04-26-kl.-09.13.43.png"><img data-id="25664" src="https://elbilen.se/wp-content/uploads/2023/04/Skarmavbild-2023-04-26-kl.-09.13.43-1030x696.png" alt="" class="wp-image-25664"/></a></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/04/Skarmavbild-2023-04-26-kl.-09.14.07.png"><img data-id="25663" src="https://elbilen.se/wp-content/uploads/2023/04/Skarmavbild-2023-04-26-kl.-09.14.07-1030x693.png" alt="" class="wp-image-25663"/></a></figure>
</figure>



<p><strong>Byd Atto 3</strong> har en klen snabbladdning. Men även i minus en grad kom den upp i maxkapacitet.<br>15–80 procent tog 36 minuter.</p>



<p><strong>Cupra Born</strong> kan ta 120 kW, men visade inte framfötterna vid någon minusgrad. Flera laddstopp visade liknande siffror. Från 15 till 80 procent tog 44 minuter</p>



<h4 class="wp-block-heading">Förbrukning och räckvidd</h4>



<p>Räckvidd under provkörningen BYD Atto 3: 280 km<br>Räckvidd under provkörningen Cupra Born: 290 km</p>



<p>Förbrukning i 90 km/h, BYD Atto 3: 1,87 kWh/mil<br>Förbrukning i 90 km/h, Cupra Born: 1,87 kWh/mil</p>



<p>Utomhustemperatur från -5 till 0 vid provkörningen.</p>



<h3 class="has-white-color has-luminous-vivid-orange-background-color has-text-color has-background wp-block-heading">Betyg BYD Atto 3: 31 av 50</h3>



<p><strong>Delbetyg:</strong></p>



<p>Köregenskaper:&nbsp;3 av 5<br>Stramt chassi, hög suv&#8211;kaross och snabb styrning ger en orolig gång.</p>



<p>Komfort:&nbsp;3 av 5<br>Det bullrar friskt från vind och däck. Ofin fjädring där hård bakvagn utmärker sig.</p>



<p>Säkerhet: 5 av 5&nbsp;<br>Trots att assistentsystemen får lågt betyg räcker det till fem Euro NCAP-stjärnor.</p>



<p>Förbrukning:&nbsp;3 av 5<br>Snittar 1,87 kW/mil vid vårt motorvägstest.&nbsp;</p>



<p>Autonomi:&nbsp;2 av 5<br>Konstant fel om rådande hastighet är direkt farligt. Överkänslig filhållning.</p>



<p>Utrustning:&nbsp;3 av 5<br>Det mesta finns, synd bara att saker har undermålig funktion.</p>



<p>Utrymmen:&nbsp;3 av 5<br>Störst bagage, men svårt att nyttja. Klart sämre baksäte än Born.</p>



<p>Ekonomi:&nbsp;2 av 5<br>Inte ens kampanjpriset går att motivera. Dyr service. Skakigt andrahandsvärde.</p>



<p>Räckvidd:&nbsp;3 av 5<br>Klarar inte 30 mil motorvägskörning vintertid.</p>



<p>Laddning:&nbsp;4 av 5<br>Lovar mindre än Born, men klarar mer under det kalla testet.&nbsp;</p>



<p>Utseende: Den stör absolut inte ögat, men var är dess identitet? Tydligt att designchefen är europé.</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/04/Inredning_004.jpg"><img src="https://elbilen.se/wp-content/uploads/2023/04/Inredning_004-1030x687.jpg" alt="" class="wp-image-25640"/></a><figcaption class="wp-element-caption">Interiören i BYD Atto 3.</figcaption></figure>



<h4 class="has-white-color has-luminous-vivid-orange-background-color has-text-color has-background wp-block-heading">Betyg Cupra Born: 36 av 50 </h4>



<p><strong>Delbetyg:</strong></p>



<p>Köregenskaper:&nbsp;4 av 5<br>Larviga e-Boost fungerar sällan och märks knappt. Smidig att köra, okej styrning med viss feedback.</p>



<p>Komfort:&nbsp;4 av 4<br>Det ställbara chassit är ett prisvärt tillval som gör underverk. Rullar mycket tyst.</p>



<p>Säkerhet:&nbsp;5 av 5<br>Fem stjärnor hos Euro NCAP och genomgående högre rondbetyg än Atto 3.</p>



<p>Förbrukning:&nbsp;3 av 5<br>Snitt 1,76 kW/mil vid vårt motorvägstest.</p>



<p>Autonomi:&nbsp;3 av 5<br>Självkörning ska inte vara tillval. Filhållningen knappt okej.</p>



<p>Utrustning:&nbsp;4 av 5<br>Full av moderna funktioner, synd bara att flertalet är tillval.</p>



<p>Utrymmen:&nbsp;4 av 5<br>Ser ut som en småbil men insidan överraskar i positiv mening. Saknar frunk.</p>



<p>Ekonomi:&nbsp;3 av 5<br>Med tillvalen man vill ha har smärtgränsen (halv-miljonen) för en Cupra passerats.</p>



<p>Räckvidd:&nbsp;3 av 5<br>Klarar inte 30 mil motorväg, vår gräns för fyra i betyg.&nbsp;</p>



<p>Laddning:&nbsp;3 av 5<br>Saknar förvärmning av batteriet, och det är synd på vintern.&nbsp;</p>



<p>Utseende: Släktskapet med VW ID 3 syns, men Born är snäppet mer spännande – bortsett från tribal-tatueringslogotypen &#8230;</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/04/Inredning_001.jpg"><img src="https://elbilen.se/wp-content/uploads/2023/04/Inredning_001-1030x687.jpg" alt="" class="wp-image-25641"/></a><figcaption class="wp-element-caption">Interiören i Cupra Born.</figcaption></figure>



<h3 class="wp-block-heading">Kostnadskalkyl – så mycket kostar bilen</h3>



<p>Alla priser och kostnader avser basversionen av repektive modell, om inte annat anges.</p>



<figure class="wp-block-table is-style-stripes"><table><tbody><tr><td>Märke</td><td><strong>BYD Atto 3</strong></td><td><strong>Cupra Born</strong></td></tr><tr><td>Pris (från)</td><td>504 900 (kampanj)</td><td>479 900</td></tr><tr><td>Privatleasing utan kontantinsats, grundpris</td><td>4 995 kr/mån</td><td>5 340 kr/mån</td></tr><tr><td>Ägandekostnad</td><td>4 855 kr/mån</td><td>4 616 kr/mån</td></tr><tr><td>Med kontantinsats utslagen**</td><td>7 660 kr/mån</td><td>7 283 kr/mån</td></tr><tr><td>Servicekostnader***</td><td></td><td></td></tr><tr><td>1:a service (2 000 mil)</td><td>1 635 kr</td><td>Se sidotext</td></tr><tr><td>2:a service (4 000 mil)</td><td>4 395 kr</td><td>Se sidotext</td></tr><tr><td>3:e service (6 000 mil)</td><td>1 635 kr</td><td>Se sidotext</td></tr><tr><td>4:e service (8 000 mil)</td><td>4 795</td><td>Se sidotext</td></tr><tr><td>Utslaget på 3 år</td><td>2 010 kr/år</td><td>Se sidotext</td></tr><tr><td>Förmånsvärde</td><td>4 497 kr/mån<br>(53 971 kr/år)</td><td>4 196 kr/mån<br>( 50 362 kr/år)</td></tr></tbody></table></figure>



<p>*Pris testbil 519 900 kr (BYD) 519 300 kr (Born)</p>



<p>** Räknat på 6,8 procents ränta, 20% kontantinsats, 60% restvärde, servicekostnader listade nedan tillkommer. Laddningskostnader och försäkring ej inräknat.</p>



<p>*** Från BYD får vi information att serviceintervallen är 1 år/2 000 mil. Skapligt tätt för en elbil. Priser på serviceverkstad i Stockholm blir på tre år 1 695+4 395+1 695 kr. Alltså totalt 7 785 kr. I Bygg din bil-funktionen på webben finns serviceavtal som tillval. Det sträcker sig över tre år, men bara 4 500 mil. Och priset är 13 654 kr. Ett tillval att undvika.</p>



<p>Cupra har en mer sansad prisbild på service. Det ingår fri service i 36 månader – utan milbegränsning. Så ska det se ut!</p>



<h4 class="wp-block-heading">Säkerhet enligt EURO NCAP</h4>



<p>Både Atto 3 och Born presterade mycket bra hos Euro NCAP, Born tar dock hem segern.</p>



<figure class="wp-block-table is-style-stripes"><table><tbody><tr><td>Märke</td><td><strong>BYD Atto 3</strong></td><td><strong>Cupra Born</strong></td></tr><tr><td>Skydd av vuxna</td><td>91%</td><td>93%</td></tr><tr><td>Skydd av barn</td><td>89%</td><td>89%</td></tr><tr><td>Fotgängare</td><td>69%</td><td>73%</td></tr><tr><td>Förarstöd</td><td>74%</td><td>80%</td></tr><tr><td>Antal stjärnor</td><td>*****</td><td>*****</td></tr></tbody></table></figure>



<h3 class="wp-block-heading">Och vinnaren är&#8230;</h3>



<div class="wp-block-cover has-custom-content-position is-position-top-left"><span aria-hidden="true" class="wp-block-cover__background has-background-dim-0 has-background-dim"></span><img class="wp-block-cover__image-background wp-image-25648" alt="" src="https://elbilen.se/wp-content/uploads/2023/04/Cupra_pan_014-1030x687.jpg" style="object-position:74% 63%" data-object-fit="cover" data-object-position="74% 63%"/><div class="wp-block-cover__inner-container is-layout-flow wp-block-cover-is-layout-flow">
<h3 class="has-white-color has-text-color wp-block-heading">Cupra Born<br>36 av 50 poäng</h3>
</div></div>



<h3 class="wp-block-heading">&#8230; Cupra Born!</h3>



<p>Det här var ingen svår utnämning. Cupra Born presterar bättre på i stort sett alla punkter.&nbsp; Cupran bjuder på en både roligare körning, men också en bekvämare sådan. Vi gillar skärmen i Atto 3 och dess intressanta batterteknik. Det mesta lämnar dock mycket att önska. Det märkligaste med Atto 3 är priset. Den borde ha varit billigare. Hade den kostat kring 350 000 kronor hade man förlåtit det mesta. Nu blir det tufft för BYD att slåss mot europeiska biltillverkare. Enda märkliga med Cupra Born var laddtiden. Vi hade förväntat oss en snabbare upplevelse vid stolpen.</p>



<h3 class="wp-block-heading">Testförarnas favoriter</h3>



<h4 class="wp-block-heading">Fredrik Sandberg: Cupra Born</h4>


<div class="wp-block-image">
<figure class="alignright size-medium"><a href="https://elbilen.se/wp-content/uploads/2021/11/Fredrik2.jpg"><img src="https://elbilen.se/wp-content/uploads/2021/11/Fredrik2-300x298.jpg" alt="" class="wp-image-20467"/></a><figcaption class="wp-element-caption">Fredrik Sandberg</figcaption></figure></div>


<p>BYD:s första modell på svenska marknaden Atto 3 är en besvikelse. Jämfört med Cupra Born är den sämre på i stort sett alla punkter. Den nya uppdaterade digitala upplevelsen på den stora skärmen är undantagen. Jag gillar gränssnittet och skärmens storlek. Körmässigt tyckte jag först att Atto 3 var en kul krabat i stan. Det var någonting som kändes familjärt i intrycket, någonting som jag saknat. Till slut insåg jag vad det var: den påminde körmässigt om den första Nissan Leaf som kom, som jag hade i tre år. Det var nostalgi jag upplevde. Inte körglädje. Cupra Born är en roligare bil att ratta, både i stan och på motorvägen. Men de borde ha markerat sig mot Volkswagen ID 3 med en kraftigare maskin mellan bakhjulen.</p>



<h4 class="wp-block-heading">Joakim Dyredand: Cupra Born</h4>


<div class="wp-block-image">
<figure class="alignleft size-medium"><a href="https://elbilen.se/wp-content/uploads/2023/04/Joakim-Dyredand_foto_oscar-malmlund.jpg"><img src="https://elbilen.se/wp-content/uploads/2023/04/Joakim-Dyredand_foto_oscar-malmlund-300x300.jpg" alt="" class="wp-image-25689"/></a><figcaption class="wp-element-caption">Joakim Dyredand</figcaption></figure></div>


<p>Den här gången behövdes det ingen lång betänketid. Jag trodde faktiskt poängskillnaden skulle bli större när uträkningarna började ta form. Det är tester likt detta som gör motorjournalistiken relevant. Som bilköpare kanske man tänker ”äh, de kostar lika mycket, jag tar den med störst skärm”. Okej, förhoppningsvis har ett beslut mer grund än så, jag generaliserar en aning. Att bilen från världens största tillverkare av elektrifierade bilar inte lyckas bättre har en förklaring. I Kina kostar BYD Yuan Plus, som den heter där, motsvarande cirka 205 000–250 000 kr och en Cupra Born runt 500 000 kr. Sett i det ljuset blir det som att jämföra äpplen och päron.</p>
