{"status":"success","username":"temijei","page_id":8962,"firstname":"TemiJei","subscription":"{\"status\":\"free\",\"expiration_date\":null,\"can_trial\":true}","elements":["{\"type\":\"text\",\"header\":\"Hey there! And Welcome.. \ud83c\udf89\",\"data\":[{\"localHTML\":\"<p>I am TemiJei. Host and owner of Slippery Streets. Your society, culture and lifestyle style podcast.<\/p><p><em>Slippery Streets is your go-to \u2018pod\u2019 for everything.This podcast is literally your go-to place for when you just want vibes or when you need a break from the hustle and bustle of everyday life.<\/em><\/p><p><em>Need the timeline\u2019s latest? Need to clear certain conflicting thoughts and opinions? You\u2019ve got stories or experiences on certain topics you would love to share? Well, I've got you and I\u2019m here for you.<\/em><\/p><p><em>This is that podcast that will definitely give you value for your time. Here we are a community and we share, care, connect with each other and we\u2019d love to hear from you. You could send me a message via my email or even still connect with me on social media. Also don\u2019t forget to Rate and leave your Likes, Reviews, Comments and Feed backs for me on wherever it is you might be listening from.<\/em><\/p><p>Please always remember I\u2019d love to hear from you and in the end it\u2019s you that makes this all worth it.<\/p><p>T.J\u2764<\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Listen and leave a voice message on Anchor\",\"url\":\"https:\/\/anchor.fm\/temijei-slipperystreets\"},{\"title\":\"Listen, rate and review on Apple Podcasts\",\"url\":\"https:\/\/podcasts.apple.com\/us\/podcast\/slippery-streets\/id1517785653\"},{\"title\":\"Listen and Subscribe on Google Podcasts\",\"url\":\"https:\/\/www.google.com\/podcasts?feed=aHR0cHM6Ly93d3cuc3ByZWFrZXIuY29tL3Nob3cvNDQ0Nzc1NC9lcGlzb2Rlcy9mZWVk\"},{\"title\":\"Listen and Download on Stitcher\",\"url\":\"https:\/\/www.stitcher.com\/s?fid=542796&refid=stpr\"},{\"title\":\"Listen, like and comment on Souncloud\",\"url\":\"https:\/\/soundcloud.com\/temi-jei\"},{\"title\":\"Listen on Radio Public\",\"url\":\"https:\/\/radiopublic.com\/slippery-streets-GqZnv5\"},{\"title\":\"Also on Audiomack\",\"url\":\"https:\/\/audiomack.com\/temijei\"},{\"title\":\"Binge on Moove TV\",\"url\":\"\"}]}","{\"type\":\"card\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/8364f9a3-118c-4d57-bc6a-f9dc5f63ac92\/eeXbo5MNU8p54kxDoN182TK37iT45j6XKqghjJj7.jpeg\",\"title\":\"The Host\",\"url\":\"http:\/\/temijei329@gmail.com\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/fd845e7f-ce7b-4e34-87bc-96d3ed430ec5\/dvLbrpXxzID8GYVwfI7tyQUF7OWpIBZc7RGjAwGp.jpeg\",\"title\":\"The Podcast\",\"url\":\"https:\/\/anchor.fm\/s\/20b4e1d0\/podcast\/rss\"}]}","{\"type\":\"video\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"url\":\"https:\/\/www.youtube.com\/embed\/cCzKxAzucrk\"}]}"],"settings":"{\"profileImage\":\"https:\/\/content.disha.ng\/pages\/67937b85-b0fe-4551-86fd-40db1b21a58f\/7ItswANt5agQRXwZFolYaY8AGvovAthoEcf3Yx2X.jpeg\",\"pageTitle\":\"SlipperyStreets\",\"bio\":\"A bi-weekly Podcast by Queen of Talk.. TemiJei. Here we discuss the issues topping and trending the charts of our Twitter and Instagram streets. Here we do drama, controversy, entertainment, trends, and everything in between... Here we share stories, ask questions and connect with each other.\\nEmail; temijei329@gmail.com, Twitter; @temijei_0\\n\",\"userStatus\":\"newUser\",\"socialLink\":[{\"id\":\"Email\",\"label\":\"email\",\"urlPrefix\":\"www.email.com\/\",\"value\":\"temijei329@gmail.com\"},{\"id\":\"Twitter\",\"label\":\"twitter\",\"urlPrefix\":\"www.twitter.com\/\",\"value\":\"temijei_0\"}],\"setTheme\":{\"selectedFont\":\"font-stylish\",\"selectedColor\":\"disha-theme-disha\",\"selectedBorder\":\"border-rounded\",\"selectedEdge\":\"edgeEnabled\",\"selectedBackground\":\"background-automatic\",\"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":"","created_on":"2020-06-06T12:27:37.000000Z","updated_on":"2024-05-05T01:00:16.000000Z"}