{"status":"success","username":"endsarsdiaspora","page_id":21030,"firstname":"#EndSars","subscription":"{\"status\":\"free\",\"expiration_date\":null}","created_on":"2020-10-20T15:32:08.000000Z","updated_on":"2020-12-13T05:15:25.000000Z","elements":["{\"type\":\"text\",\"header\":\"What's Happening - News\",\"data\":[{\"localHTML\":\"<p>This is important because new things happen <strong>everyday in every state<\/strong>. People are shot at protests, politicians make power plays, protestors are arrested, and more. Dominant news platforms do not publish these occurrences, so these are the a few that do. <strong>Beware of conventional Nigerian news platforms<\/strong>. They know how to lie o!!!<\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"The Nigerian Army Reportedly Opened Fire on Peaceful Protesters. Here\u2019s What to Know\",\"url\":\"https:\/\/time.com\/5902112\/nigeria-endsars-protest-shootings\/\"},{\"title\":\"Nigerian Protesters Say Security Forces Fired On Them, Fueling Global Outrage\",\"url\":\"https:\/\/www.washingtonpost.com\/world\/nigerian-protesters-say-security-forces-fired-on-them-amid-growing-global-outrage\/2020\/10\/21\/3b6dd1f6-1375-11eb-a258-614acf2b906d_story.html\"},{\"title\":\"Everything You Need To Know About The #EndSars Protests In Nigeria\",\"url\":\"https:\/\/femmemag.org\/everything-you-need-to-know-about-the-endsars-protests-in-nigeria\/\"},{\"title\":\"The Collective Force Behind The #EndSars Protests\",\"url\":\"https:\/\/femmemag.org\/the-collective-force-behind-the-endsars-protests\/\"}]}","{\"type\":\"video\",\"header\":\"ARISE News Live Stream\",\"subheader\":\"Arise TV is one of the only Nigerian media houses covering reports on the #EndSARS protests and beyond. Tune in (at any time) below!\",\"data\":[{\"url\":\"https:\/\/www.youtube.com\/embed\/l56n5lG01tI\"}]}","{\"type\":\"text\",\"header\":\"What's Happening - Stories\",\"data\":[{\"localHTML\":\"\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"The End Sars Movement - Zikoko\",\"url\":\"https:\/\/www.zikoko.com\/stack\/endsars-movement-edited\/\"},{\"title\":\"WE ARE NOT OKAY! - Ayomide Cole\",\"url\":\"https:\/\/ayomideycole.medium.com\/we-are-not-okay-c097e1d3d543\"}]}","{\"type\":\"video\",\"header\":\"What's Happening - Videos\",\"subheader\":\"\",\"data\":[{\"url\":\"https:\/\/www.youtube.com\/embed\/GQeDtk_ETTw\"},{\"url\":\"https:\/\/www.youtube.com\/embed\/qcEKYmrnWkM\"},{\"url\":\"https:\/\/www.youtube.com\/embed\/RJ9y0JZTqPo\"}]}","{\"type\":\"text\",\"header\":\"Getting Involved\",\"data\":[{\"localHTML\":\"<p>You have a voice. Send messages to your Nigerian Senators using the links below. The first link brings you to a list of senators that you can choose from to send a <strong><em>scripted<\/em><\/strong> email or text to your senators in Nigeria. The second is a spreadsheet made by Ayomide Cole with contact information for each senator in Nigeria.<\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"NigerianSenators.Firebaseapp.com\",\"url\":\"http:\/\/nigeriansenators.firebaseapp.com\"},{\"title\":\"Spreadsheet - Nigerian Senators Contact Information #endsars\",\"url\":\"https:\/\/docs.google.com\/spreadsheets\/d\/1PUQeeJtUm9yH8rWu8qB6hEtBpD6hjfaoZ6M5iq2Qxlc\/edit\"}]}","{\"type\":\"text\",\"header\":\"Staying Up To Date With What's Happening in Nigeria\",\"data\":[{\"localHTML\":\"<p>Again, new things happen <strong>everyday in every state<\/strong>. People are shot at protests, politicians make power plays, protestors are arrested, and more. If not for social media, what would we know about what's been going on?? Dominant news platforms do not publish these occurrences, but these are a few social media accounts that do. <\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Feminist Coalition\",\"url\":\"https:\/\/twitter.com\/feminist_co\"},{\"title\":\"FK\",\"url\":\"https:\/\/twitter.com\/fkabudu\"},{\"title\":\"Debo Macaroni\",\"url\":\"https:\/\/twitter.com\/mrmacaronii\"},{\"title\":\"Moe\",\"url\":\"https:\/\/twitter.com\/mochevious\"},{\"title\":\"Tola\",\"url\":\"http:\/\/twitter.com\/adetolaov\"},{\"title\":\"Sars Watch\",\"url\":\"https:\/\/twitter.com\/sars_watch\"},{\"title\":\"#EndSARS - The Public Archives\",\"url\":\"https:\/\/twitter.com\/EndSARSArchived\"}]}","{\"type\":\"text\",\"header\":\"What's Happening Near You? \",\"data\":[{\"localHTML\":\"<p>The links below are Instagram accounts that have been organizing events like protests for #EndSars throughout the diaspora.<\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Advance Nigeria (Atlanta-Based)\",\"url\":\"http:\/\/instagram.com\/advancenigeria\"},{\"title\":\"Bay Area\",\"url\":\"https:\/\/instagram.com\/endsarsbayarea?igshid=pa7ivpob7gtk\"},{\"title\":\"Boston\",\"url\":\"http:\/\/instagram.com\/endsarsboston\"},{\"title\":\"British Columbia\",\"url\":\"http:\/\/instagram.com\/nigeriansinbc\"},{\"title\":\"Buffalo, New York\",\"url\":\"http:\/\/instagram.com\/endsarsbuffalo\"},{\"title\":\"Calgary, Alberta, Canada\",\"url\":\"http:\/\/instagram.com\/endsarsyyc\"},{\"title\":\"Chicago\",\"url\":\"http:\/\/instagram.com\/endsars.chicago\"},{\"title\":\"Dallas-Fort Worth\",\"url\":\"https:\/\/www.instagram.com\/endsarsdfw\/\"},{\"title\":\"DC, Maryland, Virginia (DMV)\",\"url\":\"http:\/\/instagram.com\/endsarsdmv\"},{\"title\":\"Ireland\",\"url\":\"http:\/\/instagram.com\/endsarsireland\"},{\"title\":\"Los Angeles (EndSARS)\",\"url\":\"https:\/\/instagram.com\/endsarslosangeles?igshid=1jt5w6mqfdg8w\"},{\"title\":\"Los Angeles (Speak Now Africa)\",\"url\":\"http:\/\/instagram.com\/speaknowafrica\"},{\"title\":\"Netherlands\",\"url\":\"http:\/\/instagram.com\/endnigeriansinthenetherlands\"},{\"title\":\"New York\",\"url\":\"http:\/\/instagram.com\/endsarsnyc\"},{\"title\":\"Philadelphia\",\"url\":\"http:\/\/instagram.com\/phillynigerianprofessionals\"},{\"title\":\"Toronto\",\"url\":\"http:\/\/instagram.com\/endsarstoronto\"},{\"title\":\"United Kingdom\",\"url\":\"http:\/\/instagram.com\/endsarsuk\"},{\"title\":\"United States\",\"url\":\"http:\/\/instagram.com\/endsarsusa\"},{\"title\":\"End Sars Diaspora \",\"url\":\"https:\/\/www.instagram.com\/endsarsindiaspora\/\"}]}","{\"type\":\"text\",\"header\":\"Submit Your Stories\",\"data\":[{\"localHTML\":\"<p>Let your voice be heard! The publications below are accepting stories.<\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Africa 2.O Mag\",\"url\":\"http:\/\/www.a2omag.com\/contribute\"},{\"title\":\"Africa is a Country\",\"url\":\"http:\/\/africasacountry.com\/contact\"},{\"title\":\"The Femme Mag\",\"url\":\"http:\/\/femmemag.org\/submissions\/\"},{\"title\":\"Feminix Focus\",\"url\":\"http:\/\/instagram.com\/feminxfocus\"},{\"title\":\"Feminx Focus (email)\",\"url\":\"mailto:feminafocus@gmail.com\"},{\"title\":\"Gal-Dem\",\"url\":\"http:\/\/gal-dem.com\/how-to-pitch-to-gal-dem\/\"},{\"title\":\"The Unplug Collective\",\"url\":\"http:\/\/theunplugcollective.com\/submit\"},{\"title\":\"Zikoko!\",\"url\":\"http:\/\/www.zikoko.com\/about\/\"}]}","{\"type\":\"text\",\"header\":\"Donate\",\"data\":[{\"localHTML\":\"<p>For those of you with USD, GBP, EUR, etc in your pockets -- please donate!! Any amount can go a looong way. Let's use the wicked exchange rate in our favor. We're currently looking for more funds that will accept currency from abroad into Nigeria, so please check back for more ways to donate! (Feel free to use whatever talents you have at your disposal - if you cook, sell food; if you design, sell art and donate the proceeds; if you make music, have a benefit event; etc).<\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Fundraising for Oke Obi-Enadhuze's family\",\"url\":\"https:\/\/www.gofundme.com\/f\/fundraising-for-oke-obienadhuze039s-family\"},{\"title\":\"Support #ENDSARSNOW #ENDSWAT Protests in Nigeria\",\"url\":\"https:\/\/flutterwave.com\/pay\/zdfgogacmher\"},{\"title\":\"Diasporans Against SARS GoFundMe\",\"url\":\"https:\/\/www.gofundme.com\/f\/4ppyfs-diasporans-against-sars?utm_source=twitter&utm_medium=social&utm_campaign=m_pd+share-sheet\"},{\"title\":\"Project Protect\",\"url\":\"https:\/\/dashboard.flutterwave.com\/donate\/vpb2n1v8kxvx\"},{\"title\":\"Donate to the Feminist Coalition with Bitcoin\",\"url\":\"https:\/\/donatebtc.feministcoalition2020.com\/\"},{\"title\":\"Feminist Coalition Website\",\"url\":\"https:\/\/feministcoalition2020.com\/\"}]}","{\"type\":\"text\",\"header\":\"More Information, More Resources\",\"data\":[{\"localHTML\":\"<p>Linked first is an EndSARS Carrd with more information and resources. Below that is information regarding a SARS Teach-In organized by @<a href=\\\"https:\/\/twitter.com\/theAfroLegalise\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">theAfroLegalise<\/a>. It's taking place on Sunday November 1st, at 1:30 p.m. EST\/ 10:30 a.m. PST\/ 7:30 PM (GMT +1) \/ 8:30 PM (GMT +2). <br><\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"EndSARS Carrd\",\"url\":\"https:\/\/endsars.carrd.co\/\"},{\"title\":\"Naija Diaspora Policing and Abolition Teach-in (Save The Date)\",\"url\":\"https:\/\/twitter.com\/theAfroLegalise\/status\/1318578998776074242\"},{\"title\":\"Naija Diaspora Policing and Abolition Teach-in (Registration)\",\"url\":\"https:\/\/docs.google.com\/forms\/d\/e\/1FAIpQLScgNTARmxak9ErNWIZeDCR4MWgTFFTjgzwkXULOUQnj3NcEiw\/viewform\"},{\"title\":\"Feminist Coalition Website (please visit!)\",\"url\":\"https:\/\/feministcoalition2020.com\/\"}]}","{\"type\":\"text\",\"header\":\"Queer Nigerians Matter\",\"data\":[{\"localHTML\":\"<p>If ALL Nigerians Matter, Queer Nigerians Matter. Queer and Trans Nigerians are specifically targeted and harassed by SARS because of their identities. Nigeria cannot be free until we are all free. Support using the links below.<\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"End SARS: Queer Nigerians are being abused, humiliated and killed by a corrupt police unit \u2013 and it\u2019s nothing new\",\"url\":\"https:\/\/www.pinknews.co.uk\/2020\/10\/21\/end-sars-nigeria-police-protests-lgbt-gay-community\/\"},{\"title\":\"Queer Nigerians Are Being Beaten by SARS \u2014 I'm Trying to End That\",\"url\":\"https:\/\/www.out.com\/news\/2020\/10\/13\/endsars-queer-nigeria-homophobic-abuse-viral-matthew-blaise?utm_source=twitter&utm_medium=social&utm_campaign=news\"},{\"title\":\"Enioluwa Adeoluwa: How Queer people are using #EndSARS protest for self-liberation\",\"url\":\"https:\/\/therustintimes.com\/2020\/10\/14\/enioluwa-adeoluwa-how-queer-people-are-using-endsars-protest-for-self-liberation\/\"},{\"title\":\"Assata Collective Mutual Aid Fund\",\"url\":\"https:\/\/twitter.com\/AssataCollectiv\/status\/1316206260644085760\"},{\"title\":\" Invest in Black Trans Futures in Nigeria - GoFundMe\",\"url\":\"http:\/\/Bit.ly\/transnaija\"},{\"title\":\"Educate A Jobless Single Queer Mom - Fund\",\"url\":\"https:\/\/secure.changa.co.ke\/myweb\/share\/39290\"},{\"title\":\"Venmo & Cashapp to Donate for Temporary Safehouses for Queer Protestors\",\"url\":\"https:\/\/twitter.com\/Otweetoh\/status\/1318917285000679425\"}]}","{\"type\":\"text\",\"header\":\"Nigerian History + Twitter Threads\",\"data\":[{\"localHTML\":\"<p>They always tell us \\\"history repeats.\\\" Use the links below to gain more insight into why Nigeria is where it is today. The revolution is NOW - let's not make these same mistakes in our New Nigeria. <\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"History of Colonization & Policing in Nigeria \",\"url\":\"https:\/\/twitter.com\/theAfroLegalise\/status\/1315434104561848321\"},{\"title\":\"Colonial Origins of the Nigerian Police\",\"url\":\"https:\/\/folukeafrica.com\/the-colonial-origins-of-the-nigerian-police\/\"},{\"title\":\"A History of Nigeria by Jide Olanrewaju\",\"url\":\"https:\/\/youtu.be\/KgrVHrTvxC8\"},{\"title\":\"Naija Diaspora Policing and Abolition Teach-in (Registration)\",\"url\":\"https:\/\/docs.google.com\/forms\/d\/e\/1FAIpQLScgNTARmxak9ErNWIZeDCR4MWgTFFTjgzwkXULOUQnj3NcEiw\/viewform\"}]}","{\"type\":\"video\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"url\":\"https:\/\/www.youtube.com\/embed\/KgrVHrTvxC8\"}]}","{\"type\":\"text\",\"header\":\"Africa is Bleeding\",\"data\":[{\"localHTML\":\"<p>This fight against SARS is a collective fight against oppression. Our siblings in neighboring nations are suffering from deadly circumstances. It is our responsibility to inform ourselves of what's going on and to support in any way possible. Visit the links below to support and learn more.<\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"What Is Happening in Our African Nations? - Agbara Magazine\",\"url\":\"https:\/\/www.instagram.com\/p\/CGXtwh_hvrU\/\"},{\"title\":\"African Countries Are Bleeding - Agbara Magazine\",\"url\":\"https:\/\/www.instagram.com\/p\/CGm6tu0BBN8\/\"},{\"title\":\"Justice For Cameroon - Instagram\",\"url\":\"https:\/\/www.instagram.com\/justiceforcameroon\/\"},{\"title\":\"Anglophone Crisis Carrd\",\"url\":\"https:\/\/anglophonecrisis.carrd.co\/\"},{\"title\":\"'What is happening in Congo is a silent holocaust' via Twitter\",\"url\":\"https:\/\/twitter.com\/CongoleseBabes\/status\/780058759695568896\"},{\"title\":\"Oromo Protests - Instagram\",\"url\":\"https:\/\/www.instagram.com\/oromoprotests\/\"},{\"title\":\"Why Are Anti-Femicide Protesters Taking To Namibia\u2019s Streets?\",\"url\":\"https:\/\/www.aljazeera.com\/news\/2020\/10\/13\/why-are-anti-femicide-protesters-demonstrating-in-namibia\"}]}","{\"type\":\"text\",\"header\":\"Taking Care of Yourself - Email Templates\",\"data\":[{\"localHTML\":\"<p>A lot is going on. Please find the time to value and take care of yourself and your mental health, especially if that means taking time away from your normal 'responsibilities.' @<a href=\\\"https:\/\/twitter.com\/me_claireE\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">me_claireE<\/a> on Twitter created a google drive folder with several email templates that can be sent to professors and colleagues explaining the situation and asking for exemptions. The folder and each of the email templates are linked below.<\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Email Templates for Students during #EndSARS\",\"url\":\"https:\/\/drive.google.com\/drive\/folders\/1vA6FNi6hkxDqbYKX4nP48XSxOD5jVp55?usp=sharing\"},{\"title\":\"Email for Impending Midterm \/ Test\",\"url\":\"https:\/\/docs.google.com\/document\/d\/1ZM6s-Z035d9wTciBneEXJF0Tm8hnAkYwYtMXtAKtomU\/edit?usp=sharing\"},{\"title\":\"Email to General Administration\",\"url\":\"https:\/\/docs.google.com\/document\/d\/1imndD0vdnNKV-OesyFwYLi_8-2EA3_rKUeEI79vot74\/edit?usp=sharing\"},{\"title\":\"Email to Professor For General Grace Period\/Extensions\",\"url\":\"https:\/\/docs.google.com\/document\/d\/1VHnlHpZoFw28qAEs3pxcABRH9Tmh2LxiKVnI8dBi7dg\/edit?usp=sharing\"}]}","{\"type\":\"text\",\"header\":\"Taking Care of Yourself\",\"data\":[{\"localHTML\":\"<p>@<a href=\\\"instagram.com\/sabina.o\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">sabina.o<\/a> on Instagram created a really useful post with tips for self-care. Please visit the post and refer back to it from time to time. Remember to eat, sleep, speak to friends, and to try and limit your time on social media.<\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Self Care Tips for Fellow Nigerians\",\"url\":\"https:\/\/www.instagram.com\/p\/CGnJ9yyjPau\/\"}]}","{\"type\":\"text\",\"header\":\"Taking Care of Yourself\",\"data\":[{\"localHTML\":\"<p>What does \\\"taking care of yourself\\\" look like when your country is in a state like this ??? Not Sure. But here are a few #EndSars -inspired Spotify playlists. <\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Break This Shackles #EndSars\",\"url\":\"https:\/\/open.spotify.com\/playlist\/7h7dJnja8KIXuzM0lnXKTa?si=4nEWJva-RFmoyIFvLpDMaQ\"},{\"title\":\"#EndSars\",\"url\":\"https:\/\/open.spotify.com\/playlist\/7mSYtZyr99QsxxlXMUafYi?si=nn2kDWTkR0O73lTtiB76CQ\"},{\"title\":\"#EndSars - in the spirit of revolution\",\"url\":\"https:\/\/open.spotify.com\/playlist\/2qzqMa7cAiWBJNL5s5j3Me?si=ja94cjEYT1mTFMtWh7Ysog\"},{\"title\":\"EndSARS - But Make It Diaspora\",\"url\":\"https:\/\/open.spotify.com\/playlist\/74IEVrTmFge7wr6cGc2nmw?si=IPZtCaTJQoKa-ta4t143RA\"}]}","{\"type\":\"slider\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/6aa89631-e2d7-43e9-9a6c-a9f8ea36ef8a\/xE7v7cJlvPrL1FvXVhBjgFfzjjB28JjCHnZaqfFy.jpeg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/5b511fc2-9c73-4c76-b7d1-e44c920f3938\/MGiP1n7ZxkaaMjhHUcxq3QUjIcSBHd7XAuUiNIk6.jpeg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/9e1e69d8-56a0-446e-8f28-0cf3f0e89c23\/4Buy53rUH0zk4DyChUvgd7rrrgP8IcgDDjhKaiTR.jpeg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/1311a2a8-f0fa-43a1-830b-e1ac3d3d353d\/AiSNl4zDPphxtQx2CJfkvdmwt6y5SXrNKWW9803H.jpeg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/f8d1594b-bebb-41ec-9a8f-cf6e61d442d4\/RoNQ826qG0eDUruXniQOncWxKWeOAmgkdP4JcEQz.jpeg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"}]}"],"settings":"{\"profileImage\":\"https:\/\/content.disha.ng\/pages\/ae8d2354-b661-4619-92f6-00d74debd31d\/onTzqXZAJqd5eLcaFEEJ87oggDVeP8uc8SdOes6i.jpeg\",\"pageTitle\":\"Resource Guide for Diaspora Nigerians\",\"bio\":\"An #EndSARS resource guide for Nigerians in the diaspora. \\nThis will be updated daily! Please reach out to @ayomideex or @bloss.m on Instagram if you have anything you wish to add.\",\"userStatus\":\"newUser\",\"socialLink\":[{\"id\":\"YouTube\",\"label\":\"youtube\",\"urlPrefix\":\"www.youtube.com\/\",\"value\":\"watch?v=xuNHBDLKs9o\"},{\"id\":\"Instagram\",\"label\":\"instagram\",\"urlPrefix\":\"www.instagram.com\/\",\"value\":\"bloss.m\"},{\"id\":\"Twitter\",\"label\":\"twitter\",\"urlPrefix\":\"www.twitter.com\/\",\"value\":\"ayomidee_x\"},{\"id\":\"Email\",\"label\":\"email\",\"urlPrefix\":\"www.email.com\/\",\"value\":\"bdm2140@barnard.edu\"}],\"setTheme\":{\"selectedFont\":\"font-bold\",\"selectedColor\":\"disha-theme-green-gradient\",\"selectedBorder\":\"border-rounded\",\"selectedEdge\":\"edgeEnabled\",\"selectedBackground\":\"background-automatic\",\"selectedBrand\":\"brandEnabled\",\"toggleVisitorsBg\":false},\"setScripts\":{\"googleAnalytics\":\"\",\"facebookPixels\":\"\"}}"}