Nio ET7 är en värdig utmanare från öst – men för vem?


<h2 class="wp-block-heading has-medium-font-size">Nio är utan det tvekan det mest hajpade av alla nya kinesiska märken som nu kommer till Sverige. Med design, teknik och gemenskap snarare än traditionellt bilägande vill grundaren William Li visa vad Made in China står för idag – och varför det är en lyx att inte köpa sin bil.</h2>



<p>De nya spelarna från Kina har under året vuxit i snabb takt. Men Nio ska inte vara en i raden av märken som vill sälja bilar i väst. Nio vill något mer, något större.<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>



<p>Köparna är inte kunder utan ”users”, eller användare. De kan knyta kontakt med varandra genom den egna appen, köpa prylar med ”Nio Points” från butiken ”Nio Life” och dricka kaffe från ”Nio Café” på Nio House som redan finns utmed dyra adresser i Oslo och Berlin.</p>



<p>Nästa år slås portarna upp i Stockholm på ännu okänd ort. Men redan i november öppnas en mindre Nio Space i Täby Centrum norr om Stockholm.</p>



<p>Det handlar helt enkelt om lifestyle. Och faktum är att Nio inte ens vill sälja bilar.</p>



<h2 class="wp-block-heading has-medium-font-size"><strong>Kommer med två sedaner och en elsuv</strong></h2>



<p>Nio grundades så sent som 2014 Nio av William Li, den idag 48 årige vd:n. Enligt företagets egna berättelse uppstod idén när han en dag tittade ut över den bruna sörja av luftföroreningar som inte sällan utgör himmeln i Peking. Bondsonen från provinsen Anhui hade vid den här tiden blivit en av Kinas rikaste genom att grunda portalen Bitauto med information och annonser kring bilar.</p>



<p>–&nbsp;Det var en månad innan min första son föddes. Jag ville inte att hans generation skulle växa upp i en sådan miljö, säger han.</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/2022/10/Nio-Berlin-7-okt-2022-12-Edit.jpg"><img data-id="23210" src="https://elbilen.se/wp-content/uploads/2022/10/Nio-Berlin-7-okt-2022-12-Edit-1030x688.jpg" alt="" class="wp-image-23210"/></a></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2022/10/Nio-Berlin-7-okt-2022-11-Edit.jpg"><img data-id="23209" src="https://elbilen.se/wp-content/uploads/2022/10/Nio-Berlin-7-okt-2022-11-Edit-1030x688.jpg" alt="" class="wp-image-23209"/></a></figure>
<figcaption class="blocks-gallery-caption wp-element-caption">Nio EL7 och Nio ET5</figcaption></figure>



<p></p>



<p>Svaret blev elbilar och Nios motto lyder ”Blue sky is coming”. Tillsammans med Lihong Qin, med bakgrund i fastighetsbranschen, var Nio ett faktum.</p>



<p>Om grundarmyten stämmer eller inte spelar mindre roll. Säkert är att Nio nu, endast åtta år senare, är redo att utmana etablerade europeiska tillverkare på deras hemmaplan.</p>



<p>Redan förra året smygstartades europalanseringen med elsuven ES8 i Norge. Den hoppas nu över på de nya marknaderna som i stället får tre modeller från en ny generation som alla bjuder på fyrhjulsdrift. Elsuven EL7 kommer i början av nästa år och i mars är det dags för sedanen ET5 som blir en direkt utmanare till Tesla Model 3.</p>



<p>Men redan i november i år börjar leveransen av toppmodellen ET7. Det handlar om en 5,1 meter lång fyrhjulsdriven sedan med 653 hästkrafter och ett ordentligt vridmoment på 850 Nm.</p>



<p>Två batteripaket på 75 kWh för 44,5 mils räckvidd eller 100 kWh för 58 mils räckvidd finns att välja på. Med tanke på bilens låga luftmotstånd med ett cd-värde på endast 0,208 borde ET7 ändå kunnat ha längre räckvidd. Men alla hästkrafter suger onekligen energi ur batteriet.</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2022/10/Nio-Berlin-7-okt-2022-4-Edit.jpg"><img src="https://elbilen.se/wp-content/uploads/2022/10/Nio-Berlin-7-okt-2022-4-Edit-1030x688.jpg" alt="" class="wp-image-23208"/></a></figure>



<p>Nästa år ska det även gå att få ett batteri på hela 150 kW som beskrivs som ”semi-solid state” med både fast och flytande elektrolyt. Hur lång räckvidden blir då enligt WLTP har ännu inte meddelats.</p>



<p>Ombordladdaren är på 11 kW och snabbladdning är möjligt med upp till 130 kW, vilket inte är så imponerande idag. Det mindre batteriet laddas då till 80 procent på en halvtimme, det större tar 40 minuter. Men laddning med sladd är något som hamnat i skuggan av Nios ”Swap Stations”.</p>



<h2 class="wp-block-heading has-medium-font-size"><strong>Byt batteri i stället för att ladda</strong></h2>



<p>William Li kallas inte sällan för ”Kinas Elon Musk”.</p>



<p>–&nbsp;Men jag har aldrig träffat honom. Och även om jag respekterar hans arbete har Tesla inte varit förebilden för Nio som grundades innan Tesla verkligen kommit i gång. Då är det snarare Better Place som bidragit med inspiration, säger han.</p>



<p>Det israeliska bolaget Better Place såg ut att gå en lovande framtid till mötes när de 2007 lanserade sin idé med batteribyten för elbilar. I backspegeln är det tydligt att de var för tidigt ute. Pilotprojekten i Danmark och Israel blödde pengar och 2013 gick företaget i konkurs.</p>



<p>Genom att dra lärdom av deras misstag har Nio lyckats bättre med sina ”Swap Stations”. I Kina driver Nio nu över 1 100 stationer som genomfört fler än 10 miljoner batteribyten.</p>



<p>Och det är bara början.</p>



<p>I somras öppnade Nio en fabrik för stationer i Ungern. Fram till 2025 ska det finnas 1 000 Swap Stations i Europa. Fyra finns redan på plats i Norge och Tyskland. Sveriges första station planeras öppna i november i Varberg.</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2022/10/Nio-Berlin-8-okt-2022-15-Edit.jpg"><img src="https://elbilen.se/wp-content/uploads/2022/10/Nio-Berlin-8-okt-2022-15-Edit-1030x688.jpg" alt="" class="wp-image-23217"/></a></figure>



<p>Processen är enkel. Ett nytt batteri bokas på infotainmentskärmen och väl på plats parkerar bilen på egen hand. Efter knappt fem minuter med lite surrande och skakande kan du åka därifrån med ett nytt batteri laddat med 90 procents kapacitet.</p>



<p>Tanken är också att du ska kunna byta till ett större batteri inför en långresa.</p>



<p>–&nbsp;Batteribytena är vår ”unique selling point”, säger Niklas Gustafson som är försäljningschef för Nio i Sverige.</p>



<p>–&nbsp;Både genom flexibiliteten att kunna byta batteri. Men också vad det innebär för livslängden på batterierna som laddas skonsamt och kontrolleras i stationerna.</p>



<h2 class="wp-block-heading has-medium-font-size"><strong>Välbyggd men kylig</strong></h2>



<p>Själva bilen då? Kan Nio ET7 leva upp till hajpen och utmana Tesla, Mercedes och BMW? Vi tog ET7 på en långtur utanför Berlin för att undersöka saken.</p>



<p>Innanför den stiliga men lite anonyma karossen hittas en avskalad insida med en blandning av läder och hårdplast. Designchefen är för övrigt svenske Andreas Nilsson med bakgrund hos både Volvo och Ford.</p>



<p>Intrycket är inte överdrivet lyxigt, snarare lite kyligt och kliniskt. Men byggkvaliteten känns gedigen och utan skrammel. Stolarna framtill är oväntat hårda, men bekväma.</p>



<p>Gott om plats är det också, inte minst bak där även längre passagerare sitter bra trots något upphöjt golv och lite kort sittdyna. Precis som i framsätet finns även här massagefunktion som kan styras på en egen liten skärm. Luftigheten förstärks av panoramaglastaket som gör att vindrutan känns enorm med god sikt.</p>



<p>Handskfack saknas, men i mittkonsolen finns förvaring under en lucka som kan öppnas åt båda håll.</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2022/10/Nio-ET7-11.jpg"><img src="https://elbilen.se/wp-content/uploads/2022/10/Nio-ET7-11-1030x687.jpg" alt="" class="wp-image-23219"/></a></figure>



<p>I bilen vi kör sitter batteriet på 100 kWh och innan start anges en räckvidd på 52,9 mil. Den sjunker däremot snabbt under provkörningens första sträcka som utgörs av tysk Autobahn utan hastighetsbegränsning. Testbilarna har nog körts hårt och genomsnittsförbrukningen går aldrig under 2,7 kWh per mil. Enligt WLTP ligger förbrukningen på 2,2 –&nbsp;1,9 kWh per mil.</p>



<p>Toppfarten är 200 km/h som uppnås kvickt i körläget Sport+ där 0-100 km/h klaras av på 3,8 sekunder. Med Sport+ spänns den adaptiva luftfjädringen och skillnaden är tydlig mot de betydligt mjukare inställningen i lägena Comfort eller Eco.</p>



<p>Men oavsett vilket visar ET7 på ett välbalanserat chassi som gör bilen bekväm, lättstyrd och riktigt rolig att köra. Längden på 5,1 meter glöms lätt bort och från förarplats känns ET7 mer som en smidig sportvagn än autobahnkryssare.</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2022/10/Nio-Berlin-8-okt-2022-6-Edit.jpg"><img src="https://elbilen.se/wp-content/uploads/2022/10/Nio-Berlin-8-okt-2022-6-Edit-1030x688.jpg" alt="" class="wp-image-23214"/></a><figcaption class="wp-element-caption">Kan Nio utmana Tesla i Europa?</figcaption></figure>



<p>Körkänslan är alltså väl godkänd och spelar helt klart i det ”premiumsegment” som Nio vill vara i. För helhetsupplevelsen har Nio ändå en bit kvar. Ljudnivån i baksätet är till exempel betydligt högre än fram. Och vid höga hastigheter blåser det rejält genom de dolda utblåsen som om fartvinden vill ta vägen genom kupén.</p>



<h2 class="wp-block-heading has-medium-font-size"><strong>En bil med eget ansikte</strong></h2>



<p>Den virtuella assistenten Nomi (”know me”) blir nog en vattendelare som både kommer älskas och hatas.</p>



<p>Men idén är tilltalande: i stället för röststyrning där du pratar ut i tomma luften vill Nio ge sina bilar ett ansikte – bokstavligen talat. Den runda kulan framföra vindrutan vänder sig mot den som talar, blinkar och ger tummen upp eller dansar med till musiken.</p>



<p>I dagsläget förstår Nomi kinesiska, tyska och engelska, men svenska ska komma. Genom artificiell intelligens ska assistenten också bli smartare med tiden.</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2022/10/Nio-Berlin-8-okt-2022-9-Edit.jpg"><img src="https://elbilen.se/wp-content/uploads/2022/10/Nio-Berlin-8-okt-2022-9-Edit-1030x688.jpg" alt="" class="wp-image-23215"/></a><figcaption class="wp-element-caption">Nomi kan skoja till det – och irritera.</figcaption></figure>



<p>Men Nomi är också lite av en besserwisser som med sin peppiga röst gärna påpekar hur du bör förhålla dig i trafiken. Tillsammans med ständiga pipanden från autopilotsystemet blir det ibland lite väl mycket assistans.</p>



<p>Bilens autopilot bidrar också till bilens lite säregna utseende över vindrutan. Där hittas tre utbuktningar med två kameror och en Lidar-radar i mitten. På sidorna och baktill sitter fler kameror, totalt finns 11 stycken. Data från dem, fem radarsensorer och ytterligare sensorer bearbetas av superdatorn Adas, som kan behandla 8 GB i sekunden.</p>



<p>–&nbsp;Alla bilar kommer utrustade med det och till en början använder vi det för självkörning i nivå 2 med till exempel filhållning och filbyte på motorväg, säger Mirko Reuter som ansvarar för självkörning i Europa och tidigare jobbat med liknande system hos Audi.</p>



<p>Autopiloten funkar också bra, även i högre hastigheter. Ibland ”seglar” bilen ändå lite mellan markeringen som om den inte riktigt kan bestämma sig var i filen den ska ligga.</p>



<p>–&nbsp;Nästa steg är att finjustera funktionerna för att erbjuda mer assistanssystem även på landsväg och sen i stan. Men i dagsläget alltså nivå 2, föraren är ansvarig, säger Mirko Reuter.</p>



<p>Med 23 högtalare, Dolby Atmos och möjligheten att kolla film på en virtuell 130-tumsskärm med hjälp av speciella glasögon ska ET7 även bjuda på en multimediaupplevelse. Men trots olika inställningar och låtar känns ljudbilden från musiken som spelas ändå lite platt.</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2022/10/Nio-ET7-15.jpg"><img src="https://elbilen.se/wp-content/uploads/2022/10/Nio-ET7-15-1030x687.jpg" alt="" class="wp-image-23220"/></a></figure>



<p>I bilen finns appar för Spotify och Tidal, samt DAB- och en hybridradio som kombinerar radiovågor med internetradio. Men Apple Carplay eller Android Auto erbjuds inte. På den 12,8 tum stora mittskärmen hittas i stället Nios egna infotainmentsystem som fungerar snabbt. Men det tar en del tid innan du lär dig hitta rätt i alla undermenyer för att ställa in allt från ratten till accelerationstid.</p>



<p>–&nbsp;Vi vill hålla användarna inom vårt eget ekosystem och planerar därför att lansera en egen mobiltelefon nästa år som bättre integreras med bilen, säger William Li och berättar att basen för mobilen kommer vara Android.</p>



<h2 class="wp-block-heading has-medium-font-size"><strong>Flexibelt ägande som ny definition av lyx</strong></h2>



<p>Ambitionsnivån vad gäller tekniken är med andra ord hög.</p>



<p>– Vi ligger långt före våra konkurrenter när det gäller produkter och tjänster, sa Lihong Qin nyligen i en intervju utan att gå in på detaljer.</p>



<p>Men inför lanseringen här blir det tydligt vad han syftar på. Den som vill köra en Nio kan nämligen bara göra det genom en prenumeration. ”Flexibility is the new premium” lyder devisen, vilket betyder att du kan abonnera på en Nio från en upp till 60 månader.</p>



<p>Då ingår 1 500 mil om året, försäkring och service. Månadspriset ska också sjunka i takt med att bilen åldras, men oklart med hur mycket.</p>



<p>Flexibla lösningarna med kort bindningstid kan vara ett sätt att snabbt ta marknadsandelar. Nu är förmodligen kostnaden för hög för att det ska ge någon stor effekt i registreringsstatistiken.</p>



<figure class="wp-block-table is-style-stripes"><table><tbody><tr><td>Modell</td><td>Månadsavgift 36 månader</td><td>Månadsavgift flexibel</td></tr><tr><td>Nio ET7 75 kWh, 445 km</td><td>Från 13 980 kr</td><td>Från 17 599 kr</td></tr><tr><td>Nio ET7 100 kWh, 580 km</td><td>Från 15 180 kr</td><td>Från 18 799 kr</td></tr><tr><td>Nio EL7 75 kWh, 394 km</td><td>Från 14 699 kr</td><td>Från 18 849 kr</td></tr><tr><td>Nio EL7 100 kWh, 513 km</td><td>Från 16 127 kr</td><td>Från 20 247 kr</td></tr><tr><td>Nio ET5 75 kWh, 445 km</td><td>Från 10 899 kr</td><td>Från 13 499 kr</td></tr><tr><td>Nio ET5 100 kWh, 580 km</td><td>Från 13 766 kr</td><td>Från 16 918 kr</td></tr></tbody></table></figure>



<p>Möjligheten att faktiskt köpa sin bil var däremot från början inte en del av flexibiliteten. Men önskemålen om att kunna köpa bilen började strömma in direkt efter att prenumerationsmodellen presenterats. Och William Li öppnade för att det kan komma redan dagen efter presentationen.<br>– Vi behöver bara lägga till en knapp på hemsidan med ”Köp”, sa han.</p>



<p><a href="https://elbilen.se/nyheter/nio-andrar-sig-kommer-erbjuda-kop-av-bilar-i-sverige/">Och nu står det klart att knappen för att också köpa deras bilar kommer</a>. Den 21:a november kommer Nio meddela vad priserna för att köpa ET7, ET5 och EL7 blir. </p>



<p>Men oavsett vad de landar på är det rätt väg att gå för en ny spelare på marknaden. Först då kan kunder jämföra Nio mot konkurrenterna. Och med prisnivån de satt för abonnemangen riktar de sig till kunder som både har råd och kanske föredrar att köpa sin bil.</p>



<p>Då återstår bara frågan vem som ska köpa Nio ET7? Varför välja det oprövade kortet Nio framför till exempel Tesla eller Porsche Taycan? Batteribyten är så klart intressant. Men innan nätverket är uppbyggt knappast ett övertygande argument.</p>



<p>Nio själva säger att Mercedes EQE är en direkt konkurrent. Med fyrhjulsdrift börjar den på 1,4 miljoner kronor. Med 360 hästkrafter får du mindre effekt än hos ET7, men längre räckvidd på upp till 64,7 mil.</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2022/10/Nio-Berlin-8-okt-2022-3-Edit.jpg"><img src="https://elbilen.se/wp-content/uploads/2022/10/Nio-Berlin-8-okt-2022-3-Edit-1030x688.jpg" alt="" class="wp-image-23212"/></a><figcaption class="wp-element-caption">Nios grundare William Li</figcaption></figure>



<p>Priset blir därför nog mest avgörande för om Nio lyckas etablera sig eller inte. Nio själva är i alla fall övertygade om de sitter på teknik som gör att de sticker ut bland konkurrenterna.</p>



<p>När jag frågar William Li om han är en bilkille eller teknikkille tänker han en efter en stund innan det kommer ett lite kryptiskt svar:</p>



<p>– Jag är en tänkande kille.</p>



<p>Och Nio har nog en del att tänka på om de vill ta marknadsandelar här.</p>
