{"status":"success","username":"allroundgistwithfunmi","page_id":17975,"firstname":"Funmilayo Adeoti","subscription":"{\"status\":\"free\",\"expiration_date\":null}","created_on":"2020-09-01T03:26:37.000000Z","updated_on":"2021-01-19T16:53:56.000000Z","elements":["{\"type\":\"button\",\"data\":[{\"title\":\"Listen and favorite on Anchor\ud83e\udd8b\",\"url\":\"https:\/\/anchor.fm\/funmilayo-adeoti\"},{\"title\":\"Do support my podcast\ud83d\ude4f\ud83c\udffd\",\"url\":\"https:\/\/useshukran.com\/cr\/allroundgistwithfunmi\"},{\"title\":\"Read and subscribe to my blog\ud83c\udf39\",\"url\":\"https:\/\/experiencewithfab.blogspot.com\/?m=1\"},{\"title\":\"Watch and subscribe to my YouTube channel\ud83d\ude29\",\"url\":\"https:\/\/www.youtube.com\/channel\/UCWm5tBnZ3pzdB7MXLgJ37Cg\"},{\"title\":\"Follow this page for inspiring content\ud83d\udc4d\ud83c\udffd\",\"url\":\"https:\/\/www.instagram.com\/cute_fumz\/\"},{\"title\":\"Send a voice message on Anchor\ud83c\udf79\",\"url\":\"https:\/\/anchor.fm\/funmilayo-adeoti\/message\"},{\"title\":\"Follow this page for updates on my podcast\ud83d\udc83\ud83c\udffd\",\"url\":\"https:\/\/www.instagram.com\/allroundgistwithfunmi\/\"},{\"title\":\"Listen and Subscribe on Google Podcasts\ud83e\udd17\",\"url\":\"https:\/\/www.google.com\/podcasts?feed=aHR0cHM6Ly9hbmNob3IuZm0vcy8yYjY2OTU2MC9wb2RjYXN0L3Jzcw==\"},{\"title\":\"Listen and Subscribe on Spotify\ud83d\ude0a\",\"url\":\"https:\/\/open.spotify.com\/show\/0VOsp2VfGAY5VuyaNfg0JB\"},{\"title\":\"Listen and Download on Audiomack\u2764\ufe0f\",\"url\":\"https:\/\/audiomack.com\/funmilayo-adeoti\"},{\"title\":\"Ask questions\ud83d\ude09\",\"url\":\"https:\/\/forms.app\/form\/5f8f1540887a2442cb867c41\"},{\"title\":\"Do follow on Twitter\u270c\ud83c\udffd\",\"url\":\"http:\/\/twitter.com\/adeotifunmi\"},{\"title\":\"Listen and Subscribe on Overcast\ud83d\ude0b\",\"url\":\"https:\/\/overcast.fm\/itunes1524415877\/all-round-gist-with-funmi\"},{\"title\":\"Listen and Download on Spreaker\u2665\ufe0f\",\"url\":\"https:\/\/www.spreaker.com\/show\/all-round-gist-with-funmi\"},{\"title\":\"Listen and Subscribe on Radio Public\ud83d\ude18\",\"url\":\"https:\/\/radiopublic.com\/all-round-gist-with-funmi-6vqgMd\"},{\"title\":\"Listen, Like and Follow on Loftycast\ud83d\udc9e\",\"url\":\"https:\/\/loftycast.com\/users\/funmilayo-adeoti\/\"},{\"title\":\"Listen and Subscribe on Breaker\ud83d\ude01\",\"url\":\"https:\/\/www.breaker.audio\/all-round-gist-with-funmi\"},{\"title\":\"Listen on PocketCasts\u2728\",\"url\":\"https:\/\/pca.st\/46sshjlw\"},{\"title\":\"Listen, Rate and Review on Podchaser\u2763\ufe0f\",\"url\":\"https:\/\/www.podchaser.com\/podcasts\/all-round-gist-with-funmi-1421012\"},{\"title\":\"Listen and Share on Deezer\ud83d\udcab\",\"url\":\"https:\/\/www.deezer.com\/us\/show\/1715352?deferredFl=1\"},{\"title\":\"Listen and Download on Podcast Addict\ud83d\udc8b\",\"url\":\"https:\/\/podcastaddict.com\/podcast\/3098629\"}]}","{\"type\":\"card\",\"header\":\"Just me and the community\ud83d\ude0e\",\"subheader\":\"Get to know me\ud83d\ude0b\",\"data\":[{\"image\":\"\",\"title\":\"Welcome\ud83d\ude01\ud83e\udd17\",\"altText\":\"Introducing 'All Round Gist with Funmi' podcast\",\"url\":\"https:\/\/youtu.be\/HCp8i1uBhro\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/caebef18-c6c9-482c-8eaf-43eb903bc93c\/OhwS6jojVYmv4zSiPKJlTntIVTQuvrOHKCIsTaq6.jpeg\",\"title\":\"Smile always\ud83d\ude01\",\"url\":\"https:\/\/your-link.com\",\"altText\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/be96b1f8-2738-4dad-8f19-86a8fdec46b3\/BagItzO79VzyU2gsNtEJuMXFw7EiHapGYfiwKgAg.png\",\"title\":\"Cheers\",\"url\":\"https:\/\/your-link.com\",\"altText\":\"\"}]}","{\"type\":\"text\",\"header\":\"About The Host\ud83d\ude0d\",\"data\":[{\"localHTML\":\"<p>My name is <strong>Oluwafunmilayo Adeoti<\/strong>.<strong> <\/strong>I'm a writer, content creator and podcaster. A lover of Christ. An easy-going and goal oriented person.<\/p><p>I dish out great and inspiring content that encourages people to get better in life. I love telling stories and gists. I love to learn and share what I have learnt with other people in a relatable way, so you can be sure to ride on this journey with me. <\/p><p><em>Gracias.<\/em><\/p>\"}]}"],"settings":"{\"profileImage\":\"https:\/\/content.disha.ng\/pages\/569eaaf7-8996-4a30-8721-ad8b645bfe1d\/ZejvU4foX4vMWOGVfPjgEWx9icwnBVxYlWWIQBli.jpeg\",\"pageTitle\":\"Funmilayo Adeoti\",\"bio\":\"Welcome, I'm glad to have you here\ud83e\udd17. I'm here for you, feel free to talk to me and be part of this community.\\nHere we have great and inspiring content, gist on real life issues, like what you encounter on this journey and how to overcome them. Basically what's happening in this generation. Watch out for more inspiring gists. Remember I am here to take you through life's journey\ud83e\udd38\\nI call you blessed\ud83d\ude0a\\n\\nRead\ud83d\udcd6 Listen\ud83c\udfa7 Enjoy\ud83e\udd42 Share\u2764\ufe0f\",\"userStatus\":\"newUser\",\"socialLink\":[{\"id\":\"Instagram\",\"label\":\"instagram\",\"urlPrefix\":\"www.instagram.com\/\",\"value\":\"allroundgistwithfunmi\"},{\"id\":\"Email\",\"label\":\"email\",\"urlPrefix\":\"www.email.com\/\",\"value\":\"fumzy03@gmail.com\"},{\"id\":\"Twitter\",\"label\":\"twitter\",\"urlPrefix\":\"www.twitter.com\/\",\"value\":\"allroundgistwtf\"},{\"id\":\"Facebook\",\"label\":\"facebook\",\"urlPrefix\":\"www.facebook.com\/\",\"value\":\"allroundgistwithfunmi\"},{\"id\":\"YouTube\",\"label\":\"youtube\",\"urlPrefix\":\"www.youtube.com\/\",\"value\":\"Funmilayo Adeoti\"}],\"setTheme\":{\"selectedFont\":\"font-simple\",\"selectedColor\":\"disha-theme-default\",\"selectedBorder\":\"border-default\",\"selectedEdge\":\"edgeEnabled\",\"selectedBackground\":\"background-light\",\"selectedBrand\":\"brandEnabled\"},\"setScripts\":{\"googleAnalytics\":\"\",\"facebookPixels\":\"\"}}"}