Det kan finnas 1 500
spioner i Sverige

<div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/thom-thavenius/">Thom&nbsp;Thavenius</a> | 24 juni 2025<div style="float: right;" class="social-top-wrapper closed no-comments"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fdet-kan-finnas-1-500-spioner-i-sverige%2F&amp;t=Det+kan+finnas+1+500%3Cbr%3Espioner+i+Sverige"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Det+kan+finnas+1+500%3Cbr%3Espioner+i+Sverige+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fdet-kan-finnas-1-500-spioner-i-sverige%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fdet-kan-finnas-1-500-spioner-i-sverige%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Det kan finnas 1 500<br>spioner i Sverige&body=https://kvartal.se/artiklar/det-kan-finnas-1-500-spioner-i-sverige/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/180172/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div></div><div class="kv-art-ext-sep"></div><div class="mobile-share clearfix" style="margin-top: -10px; margin-bottom: 20px;"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fdet-kan-finnas-1-500-spioner-i-sverige%2F&amp;t=Det+kan+finnas+1+500%3Cbr%3Espioner+i+Sverige"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Det+kan+finnas+1+500%3Cbr%3Espioner+i+Sverige+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fdet-kan-finnas-1-500-spioner-i-sverige%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fdet-kan-finnas-1-500-spioner-i-sverige%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Det kan finnas 1 500<br>spioner i Sverige&body=https://kvartal.se/artiklar/det-kan-finnas-1-500-spioner-i-sverige/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/180172/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div><div class="article-actions"><a href="/profile" class="kv-aa-profile"><svg aria-hidden="true">  <use href="#tf-ti-user"></use></svg><span>Profil</span></a><a href="#nyhetsbrevet" onclick="newsletter()" class="newsletter"><i class="fas fa-paper-plane"></i><span>Nyhetsbrev</span></a><a class="reading-time" title="Ungefärlig lästid"><i class="far fa-clock ui"></i><span>Lästid 8 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/29014f7c-9af0-47ae-8dd5-5c28a647d424"    target = "_blank"    class  = "screen-reader-friendly"    title. = "Version som fungerar bättre med skärmläsarprogramvara">  <i class="fas fa-volume-up"></i>  <span>Skärmläsarvänlig</span></a></div><div class="in-short-wrapper closed" id="in-short-180172">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "180172"></span>    <i class="themify-icon-icon fas fa-align-left"></i>    <span class="in-short-heading">I korthet</span>    <hr class="in-short-divider" />    <div class="in-short-text">    </div>  </div></div><div class="article-beginning ">Hur många spioner finns det i Sverige och varifrån kommer de?</p>
<p>Det gjordes ett försök att besvara den frågan i utredningen om ett förstärkt skydd mot främmande makts underrättelseverksamhet från 2010, som leddes av dåvarande justitierådet <strong>Ella Nyström</strong>.<sup>1</sup> Utredningen byggde sin uppskattning på tre antaganden.</p>
</div>
<div class="rest-of-article ">
<p>För det första: Minst femton länder har underrättelseofficerare i Sverige. För det andra: De underrättelseofficerare som vistas öppet i Sverige, det vill säga deklarerade underrättelseofficerare, utgör cirka en fjärdedel av det verkliga antalet. Varje underrättelseofficerare bedöms kunna upprätthålla cirka ett tiotal kontakter med personer som de bearbetar över tid, i vissa fall över flera år. Varje underrättelseofficer bedöms slutligen kunna rekrytera och hantera en till fyra agenter samtidigt, vilket gav en uppskattning i ett spann mellan ”…ett drygt hundratal till upp över tusen agenter”.<sup>2</sup></p>
<h2>Ökat underrättelsehot</h2>
<p>15 år har gått sedan dess, och vi lever i en förändrad värld.</p>
<p>Förutom det spionage som genomförs helt på teknisk väg genom hackare eller inhämtningsplattformar, som till exempel amerikanska <em>Echelon</em> och <em>Prism</em>, utgör fortfarande inhämtning via mänskliga källor, så kallad <em>humint, </em>en avgörande förmåga för en underrättelsetjänst. Spionen och agenten som på främmande makts uppdrag inhämtar information och etablerar kontakter är ett av de största hoten mot svenska intressen i allmänhet och Sveriges säkerhet i synnerhet.</p>
<p>Sveriges strategiska placering i norra Europa, industriella framgångar och ofta världsledande forskning har bidragit till att förstärka hotbilden från främmande makts underrättelsetjänster mot Sverige. Dessutom gör det rådande geo- och säkerhetspolitiska läget att underrättelsehotet blivit än mer allvarligt (se till exempel min artikel i Kvartal: <a href="https://kvartal.se/artiklar/vi-maste-inse-att-usa-ar-ett-sakerhetshot/"><em>Vi måste inse att USA är ett säkerhetshot</em></a>).</p>
<p>I regeringens säkerhetsstrategi från 2024 beskrivs ekonomisk säkerhet som en viktig del av svensk konkurrenskraft och därmed ett område där det måste vidtas långsiktiga åtgärder för att skydda svenskt välstånd. Framgångsrik forskning och innovation ”utgör den materiella basen för den nationella säkerheten”.<sup>3</sup></p>
<p>Det handlar bland annat om halvledare, ny energi och proteinforskning. Vi är riktigt duktiga på dessa områden i Sverige. Om vi misslyckas med att skydda resultaten har vi med andra ord ett allvarligt problem.</p>
<p>Men hur stort är det faktiska underrättelsehotet? Att nå fram till en siffra för hur många personer i Sverige som just nu kan befinna sig i en rekryteringsprocess eller som redan går främmande makts ärenden är att ge sig på en stilstudie i antaganden. Den enda tröst som finns är att ingen vet. Det är en grundpelare i underrättelseverksamhet att så få som möjligt och framför allt ingen enskild har koll på allt.</p>
<h2>Sveriges vänner spionerar på vår industri</h2>
<p>Enligt Säpos bedömning är det fortfarande minst 15 länder som har underrättelseofficerare i Sverige. Den siffran har varit konstant i de beskrivningar av underrättelsehotet mot Sverige som kommunicerats under i stort sett hela 2000-talet. Ryssland och USA är redan nämnt. Flera av dessa 15 länder har dessutom mer än en underrättelseorganisation med egen närvaro i Sverige. De flesta av dessa är dessutom länder som Sverige och Säkerhetspolisen samarbetar med, alltså våra ”vänner”. Exempelvis Frankrikes <em>Direction générale de la Sécurité extérieure, </em>DGSE, USA:s CIA, Storbritanniens MI6 och tyska <em>Bundesnachrichtendienst</em>, BND.</p>
<p>Även nära allierade spionerar på varandra. I ett flertal av de länder som vi betraktar som våra nära allierade har den nationella underrättelsetjänsten, eller tjänsterna, till uppgift att bland annat bedriva underrättelseinhämtning för att stödja det egna landets prioriterade industri. Hit hör bland annat Frankrike, USA, Storbritannien och Tyskland. För amerikansk del finns det dessutom tecken på att de omstruktureringar som <strong>Trumps</strong> CIA-chef, <strong>John Ratcliffe</strong>, just nu genomför kan förstärka den amerikanska underrättelsetjänstens redan tydliga fokus på industrispionage.<sup>4</sup> Här kan nämnas att Sveriges underrättelsetjänst inte har något uttalat uppdrag att stödja svensk industri.</p>
<p>Det finns dessutom med stor sannolikhet ett antal länder vars underrättelsetjänster har närvaro i Sverige men som inte deklareras överhuvudtaget. Utöver den personal som vissa länders underrättelsetjänster deklarerar finns det alltså ett betydande mörkertal. Det vill säga underrättelseofficerare som vistas i Sverige under dold täckmantel under längre tid eller som reser in för kortare uppdrag.</p>
<p>Svensk industri, forskning och innovation är till sin natur internationell och medför näst intill obegränsade möjligheter för utländska underrättelsetjänster att skapa plattformar för att nå sina mål. Inbäddade och dolda i exempelvis internationella utbyten, industriella samarbeten eller forskningsprojekt. Nyligen kunde till exempel tidningen <em>New York Times</em> avslöja hur den ryska militära underrättelsetjänsten, GRU, under åratal använt Brasilien som bas för att bygga så kallade legender för underrättelseofficerare, alltså falska identiteter med en trovärdig livshistoria. Med kontrollerbara dokument och full historik har de sedan tagit sig vidare till sina målländer. I flertalet fall har universitet och forskartjänster utgjort plattformar för att bygga trovärdiga internationella meritförteckningar.<sup>5</sup></p>
<p>Säkerhetspolisen har fortsatt att referera till siffrorna i utredningen från 2010 när det gäller omfattningen av spioneri i Sverige.<sup>6</sup> Men ett antal faktorer har tillförts sedan dess som sammantaget bör innebära att antalet är större och att hotet i sig är mer allvarligt än 2010.</p>
<h2>Pekings och Moskvas tjänster samarbetar i Europa</h2>
<p>Rysslands första invasion i Ukraina 2014 fick konsekvenser för de ryska underrättelsetjänsternas uppträdande i Sverige och Europa.</p>
<p>Attentatet mot den ryske dubbelagenten <strong>Sergej Skripal </strong>i brittiska Salisbury i mars 2018 orsakade en våg av utvisningar av ryska underrättelseofficerare som vistades i Europa under diplomatisk täckmantel.<sup>7</sup> Även USA lät förklara 60 ryska diplomater som <em>persona non grata </em>efter spionanklagelser. Sammantaget bidrog utvisningarna till att allvarligt skada Kremls underrättelseförmåga, inte minst i Europa. Mycket tyder på att detta bidrog ytterligare till ett nytt och ökat samarbete mellan den ryska utrikesunderrättelsetjänsten, SVR, och landets militära motsvarighet, GRU, i syfte att optimera resurser och förmåga. I samband med Rysslands fullskaliga invasion av Ukraina i februari 2022 genomfördes ännu en våg av utvisningar av misstänkta ryska underrättelseofficerare som vistades i Europa under diplomatisk täckmantel. I fallet <strong>Payam Kia</strong>, den yngre av Kia-bröderna som båda dömdes för grovt spioneri i januari 2023, uppgavs exempelvis att han inledningsvis kontaktades av SVR men att det var till GRU som han lämnade över det material som hans äldre bror, <strong>Peyman</strong>, smugglat ut från bland annat Säkerhetspolisen.<sup>8</sup></p>
<p>Närmandet mellan Ryssland och Kina under kriget i Ukraina har även lett till ett ökat samarbete mellan ländernas underrättelsetjänster i Europa. Kinas underrättelsetjänst, på engelska kallad <em>Ministry of State Security</em>, MSS, rapporteras nu samarbeta med sina ryska kollegor i gemensamma påverkans- och rekryteringsoperationer.<sup>9</sup> Mycket tyder på att detta samarbete sker aktivt i stora delar av Europa, Sverige inkluderat.</p>
<p>Det är alltså mycket mörka moln i hotbilden mot Sverige.</p>
<blockquote><p>Det skulle innebära att vi har strax över 300 utländska underrättelseofficerare i Sverige som mellan sig hanterar upp till cirka 1 500 agenter.</p></blockquote>
<p>Den utmaning som Sveriges kontraspionage ställs inför när det exempelvis gäller Ryssland och Kina är att deras underrättelsetjänster har kompletterande förmågor. När det gäller förmågan att målsöka och rekrytera agenter i bredare segment i det svenska samhället, både i offentlig sektor, akademin, industri och affärsliv, har ryska SVR och GRU kapacitet som kinesiska MSS troligtvis saknar. Men genom att Kina har ett stort antal studenter, doktorander, gästforskare och andra former av investeringar och samarbeten i Sverige har landet tillgång till forskning inom ett antal strategiskt viktiga teknikområden, något som Ryssland till stor del inte har.</p>
<p>Den gamla bedömningen att cirka tusen personer redan går eller just nu förbereds för att gå främmande makts ärenden är därför sannolikt i underkant. Räknat baklänges ger uppskattningen från 2010 att det fanns cirka 250 underrättelseofficerare i Sverige och att var och en bedömdes kunna hantera upp till fyra agenter som de rekryterat och hanterar. För att räkna in de omvärldsförändringar som vi ställts inför sedan 2010 i kalkylen är det rimligt att utgå ifrån att underrättelseofficerarna antingen har blivit fler, alternativt att de är färre men har större tryck på sig att vara mer effektiva eller helt enkelt mer risktagande. Antagandet att deklarerade underrättelseofficerare utgör en fjärdedel av det totala antalet officerare bör kunna justeras till en femtedel, givet att antalet deklarerade underrättelseofficerare har varit konstant över tid. Vi bör kunna anta att de var och en hanterar cirka fem agenter. Det skulle innebära att vi har strax över 300 utländska underrättelseofficerare i Sverige som hanterar upp till cirka 1 500 agenter.</p>
<p>Som ett exportberoende land med ett omfattande internationellt utbyte är det inte ett alternativ att stänga ute världen. Däremot kan en viss paranoia för husbehov öka medvetenheten och leda till högre riskmedvetenhet och därmed klokare beslut. Vi kan börja med att inse att Sverige har mycket som andra länder bedömer vara så viktigt att man använder konspiratoriska och svikliga medel för att komma över det för egen del.</p>
<p>Alla uppskattningar om antalet agenter som finns i Sverige till trots – fallen <strong>Stig Wennerström</strong>,<strong> Stig Bergling</strong>, <strong>Bertil Ströberg</strong> och Peyman Kia påminner oss om att det bara behövs en person för att orsaka oöverblickbar skada för Sverige och svensk säkerhet.</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="180172">  <span class="button-inner-wrapper">    <span class="left-part">      <i class="ti-arrow-circle-down"></i>    </span>    <span class="right-part">      <span class="default-text">Se noter</span>      <span class="open-text">Visa mindre</span>    </span>  </span></a></p>
<div class="references">
<h3 id="noter" class="ref-heading" style="color: #000;;">Noter</h3>
<ol>
<li><em>Spioneri och annan olovlig underrättelseverksamhet: Ett förstärkt skydd för Sveriges säkerhet</em>. Betänkande från Utredningen om förstärkt skydd mot främmande makts underrättelseverksamhet. Statens offentliga utredningar 2012. s 94.</li>
<li>En officiell deklarering av underättelseofficerare går till på så sätt att landets officiella representant(-er) anmäls till Säpo, Must eller FRA som just den tjänstens representant. Gäller företrädesvis, men säkert inte uteslutande, tjänster som våra motsvarigheter samarbetar med i någon utsträckning.</li>
<li><em>Spioneri och annan olovlig underrättelseverksamhet: Ett förstärkt skydd för Sveriges säkerhet</em>. s. 73</li>
<li><em>Nationell säkerhetsstrategi</em>. Regeringens skrivelse 2023/24:163</li>
<li><em><a href="https://edition.cnn.com/2025/05/08/politics/cia-director-ratcliffe-spotlight-reorganization">Upcoming changes at CIA shine a spotlight on the spy agency’s director John Ratcliffe</a> </em>(<em>CNN,</em> 8 maj 2025)</li>
<li><a href="https://www.nytimes.com/2025/05/21/world/americas/russia-brazil-spies-deep-cover.html"><em>The Spy Factory</em></a> (<em>New York Times,</em> 21 maj 2025)</li>
<li><em><a href="https://www.svt.se/nyheter/inrikes/sapo-flera-hundra-potentiella-spioner-i-sverige">Säpo: Flera hundra potentiella spioner i Sverige</a> </em>(SVT Nyheter, 20 november 2021)</li>
<li><em><a href="https://www.hbl.fi/2018-03-26/vag-av-utvisningar-av-ryska-diplomater/">Våg av utvisningar av ryska diplomater</a> </em>(<em>Hufvudstadsbladet</em>, 26 mars 2018)</li>
<li><em><a href="https://www.svt.se/nyheter/inrikes/domde-spionen-erkanner-kontakter">Dömde spionen erkänner kontakt med rysk underrättelsetjänst</a></em> (SVT Nyheter, 17 mars 2023)</li>
<li><a href="https://www.politico.eu/article/dragon-bear-how-china-and-russias-spy-operations-overlap-in-europe/"><em>”</em><em>Dragon-Bear”: How China and Russia’s spy operations overlap in Europe </em></a>(<em>Politico,</em> 13 september 2024)</li>
</ol>
</div>
</div>
<div class="author-byline">Thom Thavenius är säkerhetsrådgivare med bakgrund från bland annat Försvarsmaktens underrättelsetjänst och Säkerhetspolisen.
</div>
</div>
