Slaveriets okända historia

<div class="kv-article-audio-player">  <div class="kv-aap-listen">    <div class="kv-listen-left">      <span>        <i class="fas fa-headphones-alt"></i>      </span>    </div>    <div class="kv-aap-listen-right">Lyssna på texten    </div>  </div><div id    = "kv-pod-holder-162514"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="162514" data-pty="SW5sw6RzdCBhcnRpa2VsIChTYW1ow6RsbGUp" data-pna="U2xhdmVyaWV0cyBva8OkbmRhIGhpc3Rvcmlh" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci8xMC01NS1zbGF2ZXJpZXRzLW9rYW5kYS1oaXN0b3JpYTIubXAz" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvMTAtNTUtc2xhdmVyaWV0cy1va2FuZGEtaGlzdG9yaWEyLm1wMw==">  <div class="kv-pod-holder-inner">    Laddar <span class="blink-me">...</span>  </div></div>  <div class="kv-listen-subscribe">    <span>Följ Kvartals poddar:</span>    <a target="_blank" href="https://podcasts.apple.com/se/podcast/kvartal/id1447122576?mt=2">Apple</a>    |     <a target="_blank" href="https://open.spotify.com/show/6NsieE1iFLypikr3slKII0?si=ppaUJpA3R-mo8L9L4XgudA">Spotify</a>  </div></div><div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/hakan-lindgren/">Håkan&nbsp;Lindgren</a> | 9 januari 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%2Fslaveriets-okanda-historia%2F&amp;t=Slaveriets+ok%C3%A4nda+historia"    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=Slaveriets+ok%C3%A4nda+historia+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fslaveriets-okanda-historia%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%2Fslaveriets-okanda-historia%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Slaveriets okända historia&body=https://kvartal.se/artiklar/slaveriets-okanda-historia/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/162514/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%2Fslaveriets-okanda-historia%2F&amp;t=Slaveriets+ok%C3%A4nda+historia"    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=Slaveriets+ok%C3%A4nda+historia+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fslaveriets-okanda-historia%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%2Fslaveriets-okanda-historia%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Slaveriets okända historia&body=https://kvartal.se/artiklar/slaveriets-okanda-historia/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/162514/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 class="listen" href="https://kvartal.se/artiklar/slaveriets-okanda-historia/?inlast=1">  <i class="fas fa-headphones-alt"></i>  <span>Inlästa texter</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 12 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/d741be0e-9118-45d2-bcb3-905c21f1764d"    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-162514">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "162514"></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 ">Egentligen ville jag bara hitta en sifferuppgift. Antalet slavar som togs västerut, till Nord- och Sydamerika, är välkänt, men den transatlantiska slavhandeln utgör inte hela historien om de brott som Afrika har utsatts för; afrikanska slavar togs också till Europa och Mellanöstern. Hur stor är den totala summan?</p>
</div>
<div class="rest-of-article ">
<p>Med tanke på hur mycket det numera talas om rasism och om att alla historiska orättvisor måste upp i ljuset borde svaret inte kräva mer än femton sekunder med Google, trodde jag. En vecka senare hade jag inte kommit någonstans. De få sifferuppgifter jag hittat var opålitliga och motsägelsefulla. Jag bestämde mig för att kontakta <strong>David Eltis</strong>.</p>
<p>Han är professor emeritus i historia vid Emory University i USA och har varit redaktör för referensverket <em>The Cambridge world history of slavery</em> i <a href="https://www.cambridge.org/core/series/cambridge-world-history-of-slavery/23FA76D353956CE0B10BDAEAED4485B9">fyra volymer</a> (2011–2021). Den transatlantiska slavhandeln är väl dokumenterad; på sajten <a href="https://www.slavevoyages.org/">slavevoyages.org</a>, som Eltis var en av initiativtagarna till, finns en databas med detaljerade uppgifter om slavtrafiken till Nord- och Sydamerika från 1501 till 1875. Där anges det totala antalet slavar som fraktades över Atlanten till 12 521 337.</p>
<p>Av dem hamnade 305 326 i USA.</p>
<h2>Hela bilden saknas</h2>
<p>Ingenstans framgår det att sajten bara berättar halva historien, eftersom slavtrafiken till Mellanöstern saknas. Hur ser den fullständiga bilden ut, frågade jag honom per e-post.</p>
<p>”Tro mig, vi skulle alla vilja se den fullständiga bilden”, svarade Eltis.</p>
<p>Problemet är bristen på källor.</p>
<p>”I många länder i Mellanöstern är myndigheterna inte särskilt angelägna att öppna sina arkiv.” De flesta historiker, tillägger Eltis, ”är överens om att slavtrafiken genom Indiska oceanen och Sahara omfattade ungefär samma antal människor under två årtusenden som den transatlantiska handeln under 350 år”.</p>
<p>Enligt de bästa uppskattningarna, skriver <strong>Rudolph T. Ware</strong> i <em>The Cambridge world history of slavery</em>, band 3, togs omkring 11,75 miljoner slavar från Afrika till Mellanöstern under perioden 650–1900. Både han och Eltis betonar att siffrorna för tiden före år 1600 är osäkra; det verkliga antalet kan vara högre eller lägre. Den totala bilden är alltså att omkring 20 miljoner människor har rövats från Afrika för att utnyttjas som slavar.</p>
<p>De 305 000 som hamnade i USA utgör 1,5 procent – ändå handlar kulturdebatten uteslutande om dem.</p>
<h2>Började och slutade tvärt</h2>
<p>Det som gör att den transatlantiska slavhandeln trots allt skiljer ut sig är inte mängden slavar, utan hastigheten. På drygt 300 år tog Västeuropa lika många slavar från Afrika som Mellanöstern hade gjort under mycket längre tid. En annan skillnad är att den europeiska slavhandeln slutade lika tvärt som den började. En växande opinion lyckades på relativt kort tid avskaffa slaveriet; något motsvarande har inte hänt på andra håll i världen.</p>
<p>Storbritannien <a href="https://kvartal.se/artiklar/1807-ett-ar-att-minnas/">förbjöd</a> slavhandeln 1807, och den brittiska flottan fick nu en motsatt uppgift: att stoppa den människohandel som andra länder fortfarande ägnade sig åt.</p>
<blockquote><p>Någon skarp gräns mellan förslavade och slavägande folk går inte att dra.</p></blockquote>
<p>Mellan 1808 och 1860 <a href="https://web.archive.org/web/20220127103448/http:/www.royalnavalmuseum.org/visit_see_victory_cfexhibition_infosheet.html">bordade</a> flottans West Africa Squadron 1 600 slavskepp och befriade omkring 150 000 afrikaner. Drygt 1 500 brittiska sjömän dog under dessa uppdrag. Det är värt att minnas, men den fullständiga bilden är inte lika smickrande för engelsmännen. Handeln stoppades visserligen, däremot var det fortfarande tillåtet att äga slavar fram till 1833. När slaveriet slutligen förbjöds helt fick brittiska slavägare ekonomisk ersättning av staten för förlorad egendom, medan de före detta slavarna inte fick någonting alls. Britterna lät också det inhemska slaveriet fortsätta i sin största koloni Indien, skriver <strong>Barry Higman</strong> i <em>The Cambridge world history of slavery</em>, band 4.</p>
<p>Om man bara jämför den transatlantiska slavhandeln med den arabiska, skriver Ware, får man en falsk uppfattning om att slaveri är något som påtvingas Afrika utifrån. Slaveri var lika normalt i Afrika som på andra kontinenter, långt innan araber och européer kom dit, även om det sannolikt inte var lika omfattande som de första europeiska resenärerna påstod. Arabernas och framför allt européernas stora efterfrågan på slavar bidrog däremot till att många fler afrikaner började ägna sig åt att ta slavar som krigsbyte och sälja dem västerut eller österut.</p>
<h2>Eftertraktat krigsbyte</h2>
<p>Handeln med afrikanska slavar är i sin tur bara en pusselbit i en större, global historia. Idag lever vi i ett samhälle där mänsklig arbetskraft, märkligt nog, mest är till besvär. Den ekonomiska och tekniska utvecklingen går ut på att göra människor överflödiga, eftersom de är för dyra jämfört med maskiner och AI, men under större delen av mänsklighetens historia har det inte varit så. Slavar var ett eftertraktat krigsbyte, lika mycket som guld och vapen, och alla folk har tagit krigsfångar när de har kunnat.</p>
<p>I förordet till <em>The Cambridge world history of slavery</em>, band 3, skriver Eltis och hans medredaktör<strong> Stanley Engerman</strong>: ”Insikten börjar nu sprida sig att alla folkslag i världen har varit både slavar och slavägare någon gång under sin historia, ofta samtidigt.”</p>
<p>Någon skarp gräns mellan förslavade och slavägande folk går inte att dra. Kanske är det en självklar insikt för specialister, men den verkar ännu inte ha nått fram till den allmänna debatten, där ”slav” fortfarande är lika med svart, och ”slavägare” lika med vit och engelsktalande.</p>
<p>När man studerar slaveriets historia bortom den sortens klichéer öppnar sig ett fönster till en värld av globala kontakter (om inget annat anges kommer alla fortsatta citat och referat från <em>The Cambridge world history of slavery</em>, band 3). Människor som köpts av swahilitalande slavhandlare på Madagaskar kunde hamna i Mekka eller på Manhattan – och slavhandlarna kunde själva tas som slavar av portugiser.</p>
<h2>Bortglömda slavar</h2>
<p>Bland de bortglömda slavarna finns också ett par miljoner östeuropéer. Hur har de kunnat försvinna så lätt ur det allmänna minnet? Det är till och med så att ordet ”slav” på svenska och flera andra språk (engelska <em>slave</em>, italienska <em>schiavo</em>, tyska <em>Sklave</em>) kommer från de slaviska folkens namn på sig själva (ryska <em>slavjanin</em>, tjeckiska <em>slovan</em>). Tatarer från Krim beräknas ha tagit omkring två miljoner ryssar, ukrainare och polacker som slavar under åren 1468–1694, skriver Eltis och <strong>William G. Clarence-Smith</strong>. Vid den tiden var Krim ett viktigt regionalt centrum för slavhandel; de flesta såldes sedan vidare till Mellanöstern.</p>
<p>Det <a href="https://en.wikipedia.org/wiki/Ottoman_Empire">osmanska riket</a>, som var sin tids mäktigaste muslimska stat, långt större än dagens Turkiet, antas ha importerat omkring 2,5 miljoner slavar från Svartahavsområdet. Istanbul omgavs av plantager där slavar odlade ris och bomull.</p>
<p>Osmanerna brukade också ta slavar från Centraleuropa. Anfallet på Wien 1683 var ”förmodligen sista gången osmanerna tog ett betydande antal krigsfångar från sina kristna fiender”, skriver Eltis och Clarence-Smith. När Ryssland blev militärt starkare minskade tillgången på slavar därifrån, och länderna i Mellanöstern övergick till att hämta sina slavar från Afrika.</p>
<p>Vikingarna var slavhandlare, skriver <strong>Neil Price</strong>, professor vid institutionen för arkeologi och antik historia i Uppsala, i sin nyutkomna bok <em>Ask och Emblas barn </em>(Daidalos 2024). Under vikingatiden blev det ”en viktig del av skandinavernas ekonomi att aktivt förvärva mänskliga ägodelar. Detta var ett av de huvudsakliga målen för vikingatågen”. Vikingarna hämtade de flesta av sina slavar från det nuvarande Ryssland och Ukraina, och de var inte bara avsedda för hemmabruk. De kunde säljas vidare till andra platser över hela Europa. Slavhandelns nätverk sträckte sig från Skandinavien till Bysans; en av de största slavmarknaderna låg i Novgorod.</p>
<h2>En miljon kristna slavar i Nordafrika</h2>
<p>Att vara sjöman under 1600- och 1700-talen var ett farligt yrke. Alla skepp som rörde sig till havs betraktades som lovligt byte. Kustborna på den iberiska halvön kallades ”människofiskare” – av ett annat skäl än det som Jesus syftade på när han värvade sina lärjungar. Svenska sjömän <a href="https://fof.se/artikel/2015/4/har-saldes-svenska-sjoman-som-slavar/">var slavar</a> hos nordafrikanska pirater, som ibland gjorde räder så långt norrut som till Irland och Island. En dryg miljon kristna antas ha varit slavar i Nordafrika under perioden 1530–1780, skriver Eltis och Clarence-Smith. Dödligheten var lika stor som på amerikanska sockerplantager.</p>
<p>Frankrike erövrade Alger 1830 för att definitivt sätta stopp för piraternas verksamhet.</p>
<p>Slaveri förekom bland Nordamerikas urinvånare innan européerna kom dit, skriver <strong>Leland Donald</strong>. Ämnet har dock inte varit föremål för särskilt mycket akademiskt intresse, eftersom den allmänna bilden av urbefolkningen som ”ädla vildar” gör att folk ”blir förvånade eller rent av gör motstånd mot påståenden om att inte alla möten mellan inhemska folkgrupper, före och i början av kontakten med européerna, var jämlika”.</p>
<p>Av Donalds kapitel framgår att de varken var bättre eller sämre än människor någon annanstans. Olika folkgrupper förde krig mot varandra och krigsfångarna utnyttjades som slavar. Under 1800-talet förekom det rent av att vissa förmögna urinvånare, som Cherokee-hövdingen <strong>John Ross</strong>, <a href="https://www.smithsonianmag.com/smithsonian-institution/how-native-american-slaveholders-complicate-trail-tears-narrative-180968339/">ägde svarta slavar</a> och drev plantager av samma slag som de vita. Sådana detaljer kan man, om man vill, betrakta som irritationsmoment och onödiga komplikationer, men i så fall – är man uppriktigt intresserad av en fullständig uppgörelse med historiska orättvisor?</p>
<h2>Muslimskt slaveri</h2>
<p>För att förstå sin samtid kan man inte bara uppmärksamma de högljudda konflikter som alla andra samlas kring – det är lika viktigt att upptäcka de potentiellt konfliktfyllda ämnen som det är fullständigt tyst om. När det gäller slaveriets historia borde de svarta i USA, Europa och Afrika ha en hel del att säga Mellanösterns muslimer.</p>
<p>När kommer den diskussionen att börja, och vilket uttryck kommer den att ta? Kommer den att bli hätsk eller konstruktiv?</p>
<p>En slutsats som tar form medan jag läser <em>The Cambridge world history of slavery</em> är att marknaden nästan alltid är starkare än lagen och samvetet – och starkare än religiösa lojaliteter. Så länge det finns pengar att tjäna väger alla andra principer lätt. Ortodoxa kristna från östra Medelhavet kallades ”halvturkar” av italienarna och utnyttjades som galärslavar. På 1600-talet fick den franske konsuln i Genoa order från Paris att inte handla med sådana slavar; de var trots allt kristna. Det struntade han i, eftersom efterfrågan var så stor.</p>
<p>Yongzheng-kejsaren, som styrde Kina 1722–35, fördömde alla former av slaveri och drog igång ett reformprogram för att omvandla slavar och livegna till fria medborgare, men misslyckades. Slaveriet är en seg tradition; ibland kan inte ens en kejsare av Kina sätta stopp för det. Det dröjde till 1902 innan slaveri förbjöds i Kina. I praktiken fortsatte det längre än så, särskilt på landsbygden.</p>
<p>I Västafrika, skriver Ware, var slavhandeln så ekonomiskt betydelsefull att det var omöjligt att förbli vid makten utan att vara inblandad. I den muslimska världen, fortsätter han, har det förts en kontinuerlig diskussion om huruvida det är tillåtet att förslava människor, och i så fall vilka människor, men de argument som har lagts fram av filosofer, jurister och teologer har sällan haft någon praktisk betydelse för affärsmännen – lika lite som i Europa, frestas jag tillägga. Det här innebär att den vanliga kultursidesdiskussionen om slaveri och rasism – som sällan når bortom vad en eller annan känd filosof har sagt om främmande folkslag – är helt irrelevant. När har affärsmännen tagit order av filosofer?</p>
<h2>Jihad för slavar</h2>
<p>”Jihad i avlägsna otrogna länder ansågs vara ett utmärkt sätt att skaffa slavar”, skriver Ware. Det faktum att många afrikaner med tiden övergick till islam tilläts inte hindra affärerna. Den äldsta bevarade arabiska texten från Västafrika, daterad till slutet av 1300-talet, är ett brev där kungen av Bornu skriver till sultanen av Egypten och klagar över att afrikaner tas som slavar trots att de är muslimer. Brevet hade ingen effekt.</p>
<blockquote><p>Utgången på slagfältet avgjorde vem som slutade som slav eller herre.</p></blockquote>
<p>Arabiska slavhandlare struntade i religionen och gick bara efter hudfärgen; när de mötte svarta afrikaner såg de inte något annat än slavar som ännu inte var infångade. <strong>Abd al-Salam Jasus</strong>, rättslärd från Marocko (den arabiska termen är <em>alim</em>), avrättades för att han försvarade muslimska afrikaner mot slaveriet.</p>
<p>I början av 1500-talet lämnade perserna sunni och övergick till shiitisk islam, varpå de genast betraktades som utmärkt slavmaterial av sina sunnitiska grannar osmanerna. Perserna återgäldade artigheten och tog sunnitiska muslimer som slavar när de kunde. Förmögna persiska familjer kunde ha svarta slavar ända in på 1900-talet, <a href="https://www.theguardian.com/world/iran-blog/2016/jan/14/african-slavery-in-qajar-iran-in-photos">berättar</a> antropologen <strong>Pedram Khosronejad</strong> för <em>The Guardian</em> (14/1 2016).</p>
<h2>Hudfärg utan betydelse</h2>
<p>En andra slutsats är att slaveri ursprungligen inte var kopplat till rasism. Romare, mongoler och andra erövrande folk struntade fullständigt i vilken hudfärg du hade. Att de förslavade vissa – men inte andra – av de folkgrupper de mötte under sina erövringståg berodde helt enkelt på att de kom undan med det. Utgången på slagfältet avgjorde vem som slutade som slav eller herre. Om jag är fullständigt underlägsen dig blir jag din slav. Är du underlägsen blir du min. Är vi någorlunda jämnstarka förblir vi fiender, möts i nya krig, och börjar till sist kanske respektera varandra så mycket att vi ingår någon form av fredlig samexistens.</p>
<p>Över hela världen, från Asien till det förcolumbianska Amerika, har en mängd folkslag förslavats av sina grannar. Varje förslavat folk har, av sina ägare, påståtts ha någon form av slavmentalitet, så att den behandling de utsätts för ska framstå som berättigad och inte såra ägarnas eventuella samvete. Först under de senaste århundradena, skriver Eltis och Clarence-Smith, sker en avgörande förändring: slaveriet rasifieras.</p>
<p>Européer och araber börjar intala sig själva att svarta afrikaner, till skillnad från alla andra, är en sämre sorts människor, födda att köpas och säljas. Att slaveri kom att förknippas så starkt med hudfärg kallar Eltis och Clarence-Smith ”en anomali i slaveriets långa historia”.</p>
<p>I vår tid är kopplingen mellan hudfärg och en socialt underlägsen position så stark att de anser sig behöva förklara för sina läsare att det är svårt att avgöra vem som är ”vit” och ”icke-vit” när perser och indier för krig mot varandra.</p>
<h2>Passar inte in i konfliktlinjerna</h2>
<p>Den europeiska rasismen är grundligt genomforskad (vilket inte får den att försvinna). ”Historien om svarthet och slaveri i den muslimska världen förblir oskriven”, säger Ware i sitt kapitel om slaveriet i det muslimska Afrika. Det är en aning underligt, eftersom världen just nu är så besatt av de båda ämnena rasism och islam. Eller också är det just därför. Att börja diskutera rasismen hos arabiska slavhandlare skulle inte passa in i de nuvarande kulturella konfliktlinjerna – vita mot svarta och Väst mot islam.</p>
<p>Men det första man bör göra med den sortens heta kulturkonflikter är att sabotera dem genom att läsa så mycket historia att man förstår att de inte är eviga eller naturliga. De är föränderliga, och de kommer att förändras igen.</p>
<p>En tredje slutsats är att USA:s historia dominerar våra föreställningar om ras och slaveri på ett olyckligt sätt. Vi tror att rasism och slaveri alltid måste se ut exakt som i USA, vilket gör att varje lands historia är på väg att förvandlas till en kopia av USA:s. Det hjälper inte människor utanför Amerika att förstå sitt förflutna, och det hjälper inte ens amerikanerna själva. Tvärtom är det kanske så att det bästa som skulle kunna hända amerikanerna är att de började betrakta sin egen historia i en global kontext.</p>
<p>Slaveriets historia är lång och varierad. En artikel av det här slaget kan bara ge en antydan om de orättvisor som människor har utsatt varandra för. Men en sak vill jag tillägga innan jag slutar: tro inte att <a href="https://kvartal.se/artiklar/dagens-slav-ar-en-kvinna-i-ett-afrikanskt-land/">slaveriets historia</a> är över. Just nu befinner sig <a href="https://www.ilo.org/resource/news/50-million-people-worldwide-modern-slavery-0">50 miljoner människor</a> i slaveri enligt den internationella fackföreningen ILO.</p>
<p>De flesta, <a href="https://www.walkfree.org/global-slavery-index/">skriver</a> människorättsorganisationen Walk free, finns i Indien (11 miljoner), Kina (5,8 miljoner), Nordkorea (2,6 miljoner) och Pakistan (2,3 miljoner).</p>
<div class="author-byline">Håkan Lindgren är frilansskribent.
</div>
</div>
