{"status":"success","username":"senseclinicpodcast","page_id":19698,"firstname":"Sense Clinic","subscription":"{\"status\":\"free\",\"expiration_date\":null,\"can_trial\":true}","elements":["{\"type\":\"text\",\"header\":\"Welcome \ud83c\udf89\",\"data\":[{\"localHTML\":\"<p><strong>Hey there,<\/strong><\/p><p><strong>Sense Clinic is here to stay, forever. On this podcast, you should expect to listen to undiluted conversation on authentic life concerns.<\/strong><\/p><p><strong>It's readily available on Anchor, Spotify, Google Podcasts, Radio Republic, Breaker and Pocket Casts.<\/strong><\/p><p><strong>Listen via the links below<\/strong> \ud83d\udc47<strong>and<\/strong> <strong>do not forget to mark your calendars for Saturdays for new episode<\/strong><\/p><p><a href=\\\"https:\/\/anchor.fm\/senseclinicpodcast\/episodes\/Sense-Clinic-Trailer-ejcf5r\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">https:\/\/anchor.fm\/senseclinicpodcast\/episodes\/Sense-Clinic-Trailer-ejcf5r<\/a><\/p><p><a href=\\\"https:\/\/open.spotify.com\/show\/4VjMdWJ7PlVXTXXWS0ZY1s\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">https:\/\/open.spotify.com\/show\/4VjMdWJ7PlVXTXXWS0ZY1s<\/a><\/p><p>RadioPublic: <a href=\\\"https:\/\/radiopublic.com\/sense-clinic-6pryLJ\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">https:\/\/radiopublic.com\/sense-clinic-6pryLJ<\/a><\/p><p>Breaker: <a href=\\\"https:\/\/www.breaker.audio\/sense-clinic\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">https:\/\/www.breaker.audio\/sense-clinic<\/a><\/p><p>Google Podcasts:<\/p><p><a href=\\\"https:\/\/www.google.com\/podcasts?feed=aHR0cHM6Ly9hbmNob3IuZm0vcy8xMjU0ZDI4MC9wb2RjYXN0L3Jzcw==\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">https:\/\/www.google.com\/podcasts?feed=aHR0cHM6Ly9hbmNob3IuZm0vcy8xMjU0ZDI4MC9wb2RjYXN0L3Jzcw==<\/a><\/p><p>Pocket Casts: <a href=\\\"https:\/\/pca.st\/evrpiytz\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">https:\/\/pca.st\/evrpiytz<\/a><\/p><p><\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Exciting News\ud83d\ude03\",\"url\":\"https:\/\/www.instagram.com\/p\/CFXmyY2hGp7\/?igshid=1ib2pthvqgasc\"},{\"title\":\"We are live!!!\",\"url\":\"https:\/\/www.instagram.com\/p\/CFNhIpmBIbz\/?igshid=1cdbfy47ap1xm\"}]}","{\"type\":\"slider\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/357fbd0e-c168-4b43-a98b-31644980ef1a\/CQRggxhhxlccgdvq0Nfud6yftpwEFdeHtC2qXfIy.jpeg\",\"title\":\"Guess who \ud83d\ude03\",\"altText\":\"\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/52eb4bf6-5668-415a-8d57-6f812e240aaf\/D3HdQvysC9fpO7KUEe2aMcps1h1YfVGOublSS4Z2.jpeg\",\"title\":\"We value your feedback, so let us know what you think\",\"altText\":\"\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/2f6a2243-be73-4529-b921-0931d1dd13b2\/xddS1mD4h4dPqjntuMIwBwryid0SaIGYN2RKJzfK.png\",\"title\":\"The Easiest way to record a Podcast. Download Anchor on Play store or App store, to get started\",\"altText\":\"\",\"url\":\"\"}]}"],"settings":"{\"profileImage\":\"https:\/\/content.disha.ng\/pages\/249fe5ad-f988-4d8b-9509-611b13776e2b\/OtFxcDu28QG1lAxXh5GXGMYDrfULumQ8TOQIvgRy.jpeg\",\"pageTitle\":\"Sense Clinic\",\"bio\":\"A weekly, undiluted conversation where we separate the truth from fiction\",\"userStatus\":\"newUser\",\"socialLink\":[{\"id\":\"Instagram\",\"label\":\"instagram\",\"urlPrefix\":\"www.instagram.com\/\",\"value\":\"senseclinicpod?igshid=19g6tukxpfnsf\"},{\"id\":\"Email\",\"label\":\"email\",\"urlPrefix\":\"www.email.com\/\",\"value\":\"senseclinicpodcast@gmail.com\"},{\"id\":\"Telegram\",\"label\":\"telegram\",\"urlPrefix\":\"www.telegram.me\/\",\"value\":\"https:\/\/t.me\/joinchat\/MNmWpRWQZIUpmSR-dyCwHg\"}],\"setTheme\":{\"selectedFont\":\"font-bold\",\"selectedColor\":\"disha-theme-green-gradient\",\"selectedBorder\":\"border-rounded\",\"selectedEdge\":\"edgeEnabled\",\"selectedBackground\":\"background-dark\",\"selectedBrand\":\"brandEnabled\",\"toggleVisitorsBg\":false},\"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-09-23T23:28:16.000000Z","updated_on":"2021-11-26T17:44:04.000000Z"}