{"status":"success","username":"support4africasmes","page_id":4194,"firstname":"#Support4AfricaSMEs","subscription":"{\"status\":\"free\",\"expiration_date\":null,\"can_trial\":true}","elements":["{\"type\":\"video\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"url\":\"https:\/\/www.youtube.com\/embed\/EJD70-wfBWU\"}]}","{\"type\":\"card\",\"header\":\"COVID- 19: A Call for Support for African SMEs\",\"subheader\":\"In the wake of the Corona-Virus (COVID-19), Africa finds itself in at the precipice of an economic crisis along with the rest of the world. At the heart of the pandemic lie the African SMEs who are in danger of extinction\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/f4628f33-27f3-40d5-88d6-78c136b63d24\/imiIT5D0SPoEqvTw3g2rxR4MLUUbE2CiWhLaSX0m.jpeg\",\"title\":\"The African Farmers Stories - Unlocking the Food Supply Chain on Wednesday 17th June at 2PM WAT\",\"url\":\"https:\/\/us02web.zoom.us\/meeting\/register\/tZUsfuyvrTMtGtbqbXtN2-mc7CHptKvOik0x\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/94f98110-4b5b-4581-a787-b24634f1f02f\/HktF4m0kHclpdxPsJhVQLbTF8oZa2rVMuOVDy6tU.jpeg\",\"title\":\"COVID- 19: A Call for Support for African SMEs\",\"url\":\"https:\/\/www.linkedin.com\/pulse\/covid-19-call-support-african-smes-parminder-vir-obe\/\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/597275d5-ca9d-48cd-ae64-dd542c483e07\/QKqdw2lVITljBSkzBh6fcA5ND6p2zgOTPPla50gH.jpeg\",\"title\":\"The African Famers' Stories with Uwem\",\"url\":\"https:\/\/www.youtube.com\/watch?v=zlgnVp3KfBs&list=PLElOwdoaFHZfr1xemPRGpPaaxp_lTtaMn\"}]}","{\"type\":\"text\",\"header\":\"\",\"data\":[{\"localHTML\":\"<p>In the wake of the Corona-Virus (COVID-19), Africa finds itself in at the precipice of an economic crisis along with the rest of the world. At the heart of the pandemic lie the African SMEs who are in danger of extinction. Swift action is required to aid these Entrepreneurs before it is too late.<\/p><p><strong><a href=\\\"https:\/\/www.linkedin.com\/feed\/hashtag\/?highlightedUpdateUrns=urn%3Ali%3Aactivity%3A6652917986749358080&amp;keywords=%23support4AfricaSMEs&amp;originTrackingId=JaYTcvoURs6yGnfVsUw6NQ%3D%3D\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">#Support4AfricaSMEs<\/a><\/strong> campaign is championed by <strong><a href=\\\"https:\/\/www.linkedin.com\/in\/ACoAAAHHGKQBuzEG7hMNyDmEdsRKcelAq-Rnc0M\/\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">Parminder Vir OBE<\/a><\/strong> and an amazing volunteer team across Africa by making resources available to budding entrepreneurs and SMEs which will help them survive the looming financial crisis; from access to markets, opportunities in agriculture, to available financial interventions by different government and financial institutions across Africa.<\/p><p>We would like to invite you to join the <strong><a href=\\\"https:\/\/www.linkedin.com\/pulse\/covid-19-call-support-african-smes-parminder-vir-obe\/\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">#Support4AfricaSMEs<\/a> <\/strong>campaign:<\/p><ul><li><p>To promote your own schemes and initiatives and extend the reach of your networks;<\/p><\/li><li><p>To share further information, tools, and in-kind support resources;<\/p><\/li><li><p>To help spread our campaign through your networks.<\/p><\/li><\/ul>\"}]}","{\"type\":\"list\",\"header\":\"Propagating Hope\",\"subheader\":\"Stories from African SMEs Adminst Covid-19\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/ee55c185-4578-4552-a53f-c65528205b85\/AVHl3A8cBkq360f9AZzLV0f95P2aF8RDR5ZIySBE.jpeg\",\"title\":\"Propagating Hope\",\"desc\":\"A Call For Stories From the African SMEs and African Entrepreneur Support Organisations Amidst Covid-19\",\"url\":\"https:\/\/www.linkedin.com\/pulse\/propagating-hope-call-stories-from-african-smes-support-vir-obe\/?ref=dishapages\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/8ba246ec-c756-45b3-a343-41dfc2675533\/tXqWpmKo6AuLwf37RAVQafCPwzwvoa2bOFAY7za6.jpeg\",\"title\":\"African Pearl: AIDS, loss and redemption in the shadow of the Rwenzori Mountains by Pamela Brown-Peterside\",\"desc\":\"\",\"url\":\"https:\/\/www.linkedin.com\/pulse\/propagating-hope-stories-from-africa-african-pearl-aids-vir-obe\/\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/02887769-7e18-4d90-9d46-f0ad93ce069b\/mTHZsfYmhQN2DucVd0esYmsKeV8SHFTLcTlgQ4MF.jpeg\",\"title\":\"Booomers Bamboo Bikes From Ghana\",\"desc\":\"Booomers Bamboo Bikes From Ghana Positions Itself As An Essential Commodity\",\"url\":\"https:\/\/www.linkedin.com\/pulse\/propagating-hope-stories-from-african-smes-amidst-covid19-vir-obe-4f\/\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/bd9db7c9-6dd9-4393-8546-c632c06c7d7e\/3Dqon9XtCywCuecoEjhqURHSihMHUSzVyZR0Tk6U.jpeg\",\"title\":\"The Somo Community in Kenya\",\"desc\":\"The Somo community of entrepreneurs in Kenya are taking vital steps to mitigate the effect of the COVID19 epidemic on their business and communities\",\"url\":\"https:\/\/www.linkedin.com\/feed\/update\/urn:li:activity:6664178853876912129\/\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/07bee63b-ac77-4399-a205-e546904bd9fa\/vavVvL8Bl1RrNTneu8WOV720Imxv92xyhqdZXSV3.jpeg\",\"title\":\"Paul Kagame on Africa's mindset\",\"desc\":\"Africa needs to change its mindset in order to properly maximize the abundant resources that are already available \",\"url\":\"https:\/\/www.linkedin.com\/posts\/parmindervir_support4africasmes-covid19-staysafestayhome-activity-6663754573292810240-Arun\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/73fe2fae-2be5-44de-a3da-f987eb9ed501\/qGarr9dKb1MgrQZ2DsmYd3X9XIl0fKyE7V2DEMfZ.jpeg\",\"title\":\"Help Mum\",\"desc\":\"Help Mum is an organisation dedicated to the reduction of maternal and infant mortality in Nigeria\",\"url\":\"https:\/\/www.linkedin.com\/posts\/parmindervir_support4africasmes-covid19-lagosnigeria-activity-6661932562186805248-0kD7\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/d0d8cd56-8864-4fa0-aec0-0797c45c3a58\/DjHtTRyixHNFQPNhZYBtLd2TvGKvFiuRv9Sess0r.jpeg\",\"title\":\"ACE-Tech Auto Services\",\"desc\":\"ACE-Tech Auto Services is an automobile company located in Lagos\",\"url\":\"https:\/\/lnkd.in\/dPMFWmd\"}]}","{\"type\":\"list\",\"header\":\"IN THE NEWS\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/41ab7d15-e5dc-43ff-bfb1-da99c3abc072\/ur17c3hpXN0v9Gq8heKqTQ2eOwxHnZuyNgtUpBhf.jpeg\",\"title\":\"Building the food supply chain: The role of agricultural technology (BusinessDay)\",\"desc\":\"\",\"url\":\"https:\/\/businessday.ng\/news\/article\/building-the-food-supply-chain-the-role-of-agricultural-technology\/\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/8dd153d0-68c4-4670-a781-4f5cbabb3db0\/e6W0tA6KL0XHf2YKI9BNlpiiOUM3xwNpLT1aH2EL.jpeg\",\"title\":\"SIGN THE PETITION TODAY! 10 Important Relief Actions for Nigerian SMEs \",\"desc\":\"Policy recommendation for the Nigerian Government\",\"url\":\"https:\/\/www.linkedin.com\/pulse\/sign-petition-today-10-important-relief-actions-nigerian-vir-obe\/\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/73ddae7b-c6b9-4645-9836-a493abeaec71\/WXy2501v9fr4EFbf3cH0U2WIq3CH34XYrKOHW4Qk.png\",\"title\":\"UN GUIDANCE FOR MSME BUSINESS RECOVERY\",\"desc\":\"Business Recovery in the Wake of the COVID - 19 pandemic\",\"url\":\"https:\/\/www.dropbox.com\/s\/xiyz2uzlfq5k5ka\/Guide%20MSMEs%20EN%20updated.pdf?dl=0\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/b74fcd07-a6e4-46a4-9e80-7b7c10b5710c\/EOqruNWwydlR5in3JiSJFRiNTZ9hiqxbnVzTA4sa.jpeg\",\"title\":\"What Jack Ma Is Doing for Africa and African SMEs\",\"desc\":\"The Jack Ma Foundation announced the official launch of the second edition of the \u201cAfrica\u2019s Business Heroes\u201d (ABH) prize competition\",\"url\":\"https:\/\/www.linkedin.com\/pulse\/what-jack-ma-doing-africa-african-smes-parminder-vir-obe\/\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/7e961fce-9a43-4061-9d9a-a857a8bbc9d1\/oOjVJIQoTlKNqqdRVlpQwfN2M7Wpbuq7KRXGu7Du.png\",\"title\":\"Half a billion people could be pushed into poverty by coronavirus\",\"desc\":\"The economic fallout from the coronavirus pandemic could push half a billion more people into poverty unless urgent action is taken\",\"url\":\"https:\/\/www.oxfam.org\/en\/press-releases\/half-billion-people-could-be-pushed-poverty-coronavirus-warns-oxfam\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/9f9ae32a-d5ca-4c04-b149-ac87bc4d644b\/VujL6E8q6TkE6PIAcAElwFPQyfFk2Tw4sOoiLuo9.jpeg\",\"title\":\"#SupportForAfricaSMEs: OP-ED by Akinwumi Adesina, President Africa Development Bank\",\"desc\":\"\u201cThe fact is, if we do not collectively defeat the coronavirus in Africa, we will not defeat it anywhere else in the world. This is an existential challenge that requires all hands to be on deck. Today, more than ever, we must be our brothers and sisters\u2019 keepers.\u201d \",\"url\":\"https:\/\/www.linkedin.com\/pulse\/supportforafricasmes-op-ed-akinwumi-adesina-president-vir-obe\/?trackingId=k75TAFK%2BSBCHb0PkVj9cSQ%3D%3D\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/36d527e4-ca5e-48c2-acdd-070f01dbfaf8\/d5JDHAP9DVh0rPEdhAYXoc3x9pFiZOIzUChM5XPh.jpeg\",\"title\":\"i4Policy: Co-creating response and recovery for Covid19 in Africa\",\"desc\":\"Innovation For Policy Foundation (i4Policy) based in Rwanda is leading the conversation on co-creating Response and Recovery on Covid19\",\"url\":\"https:\/\/lnkd.in\/d2mQmEc\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"READ MORE ON LINKEDIN\",\"url\":\"https:\/\/www.linkedin.com\/feed\/hashtag\/support4africasmes\/\"}]}","{\"type\":\"list\",\"header\":\"RESOURCES TO CHECK OUT\",\"subheader\":\"Here we curate and share solutions and interventions for African SMEs \",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/08ebf8e6-c3ea-44b9-91ab-04bf635dd6e0\/vzM7HFtls4319K3Mhi1tBlThIGYtqlHwJHqd3Pq1.jpeg\",\"title\":\"Grant funding scheme for vulnerable supply chains\",\"desc\":\"\",\"url\":\"https:\/\/www.great.gov.uk\/campaigns\/grant-funding-scheme-vulnerable-supply-chains\/\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/a89d871f-682e-463e-bd60-695261e9c4fa\/UGk23vuC0taGpoSeznN5EEKMSN2rhFVc99rQmJrS.jpeg\",\"title\":\"Call for Application for Africa's Business Heroes Competition 2020\",\"desc\":\"Apply for the Africa's Business Heroes Competition\",\"url\":\"https:\/\/www.linkedin.com\/pulse\/jack-ma-foundations-africa-netpreneur-prize-anpi-call-vir-obe\/\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/311e6770-14cb-4f60-843d-30283273b531\/Fapp7QdPfzjnMoHID2ptNl2rtIfbFYxUu7QWpbEJ.jpeg\",\"title\":\"Jack Ma Foundation African Netpreneur Prize Initiative Weekly Webinar\",\"desc\":\"Interactive sessions aimed at providing applicants with key business skills to address business challenges in English and French\",\"url\":\"https:\/\/lnkd.in\/dmfyiDs\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/7bc00f29-00b4-4ffd-9565-3fe5f7539147\/ejHaXqerAG1nCQ79OjA1V3RBTD5wDV8t6IGpnXqQ.jpeg\",\"title\":\"COVID-19- Unlocking digital opportunities in Agriculture and Agribusiness\",\"desc\":\"In Africa, we are all waking up to appreciate the value and benefits that the long underrated agricultural sector brings in respect to the survival of general population\",\"url\":\"https:\/\/www.linkedin.com\/pulse\/covid-19-unlocking-digital-opportunities-agriculture-madedor-\/?trackingId=qi7FJHS2T%2F2urwOCRF6s%2Bw%3D%3D\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/31b2d611-9ac5-4eb6-94c9-5a4acdd2fa9a\/bE3uUC4zj96qrjaWx4PPbYm4a6P1uMQGiM8yZK81.jpeg\",\"title\":\"Create your profile on EuroQuity\",\"desc\":\"Are you a small company looking for bridge funding?\",\"url\":\"https:\/\/www.euroquity.com\/\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/0bbf0f62-0f87-4de1-a8e6-b0f7a0dd519d\/5CqaZQS7lHLKHpbZh6YUVeWNhjhLxlxp1Ze9cnvs.png\",\"title\":\"Call for Proposals: Digital Solutions for Governments to Tackle the Coronavirus (COVID-19) Pandemic in Africa\",\"desc\":\"Smart Africa Secretariat seeks to support digital health services projects that aim at improving and accelerating the African governments response to Covid19\",\"url\":\"https:\/\/we.tl\/t-xDZlxuhqY7\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/b523c6f5-c313-4570-9998-a1ff240979e6\/if65KBJAU9eABusVCIh4ckuULDfZOyvNsfZxqWe8.png\",\"title\":\"COVID-19 SME SURVIVAL KIT:  How can I pivot my business?\",\"desc\":\"The world is experiencing huge shifts in the global economy, startups are reeling from the after-effects of the Covid19 pandemic and resulting economic conditions\",\"url\":\"https:\/\/www.linkedin.com\/pulse\/how-can-i-pivot-my-business-uwem-uwemakpan\"}]}","{\"type\":\"video\",\"header\":\"Tell Africa Farmers' Stories Docuseries\",\"subheader\":\"\",\"data\":[{\"url\":\"https:\/\/www.youtube.com\/embed\/iWLDYxyJGLI\"},{\"url\":\"https:\/\/www.youtube.com\/embed\/xn-9SLxHc7g\"},{\"url\":\"https:\/\/www.youtube.com\/embed\/fmhMUdELYvY\"},{\"url\":\"https:\/\/www.youtube.com\/embed\/TV-oL-SDswc\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"LET'S WORK TOGETHER\",\"url\":\"mailto:info@support4africasmes.com\"},{\"title\":\"ABOUT PARMINDER VIR \",\"url\":\"http:\/\/parmindervir.com\/about-3\/\"}]}"],"settings":"{\"profileImage\":\"https:\/\/content.disha.ng\/pages\/1a336476-666d-4c84-88f7-fab18c8573f5\/oM7fQnLPfEh8ln0m2zIGirdjtUMkSvskJvcGymAl.jpeg\",\"pageTitle\":\"#Support4AfricaSMEs\",\"userStatus\":\"newUser\",\"socialLink\":[{\"id\":\"Email\",\"label\":\"email\",\"urlPrefix\":\"www.email.com\/\",\"value\":\"infosupport4africasmes.com\"},{\"id\":\"LinkedIn\",\"label\":\"linkedin\",\"urlPrefix\":\"www.linkedin.com\/in\/\",\"value\":\"feedhashtag\/?keywords=%23Support4AfricaSMEs\"}],\"setTheme\":{\"selectedFont\":\"font-simple\",\"selectedColor\":\"disha-theme-pink-gradient\",\"selectedBorder\":\"border-default\",\"selectedEdge\":\"edgeEnabled\",\"selectedBackground\":\"background-dark\",\"selectedBrand\":\"brandEnabled\"},\"setScripts\":{\"googleAnalytics\":\"\",\"facebookPixels\":\"\"}}","currency":null,"country":null,"industry":null,"is_discoverable":1,"is_payment_on":1,"has_products":false,"locale":"en","rave_islive":0,"rave_keys":null,"created_on":"2020-04-07T20:32:22.000000Z","updated_on":"2023-03-29T01:00:13.000000Z"}