{"status":"success","username":"luvlybee","page_id":10802,"firstname":"Blessing E. Enofe","subscription":"{\"status\":\"free\",\"expiration_date\":null}","elements":["{\"type\":\"card\",\"header\":\"BLESSING'S PROFILES\",\"subheader\":\"Thank you for stopping by. You can know more about Blessing by visiting these pages. You are cherished!\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/561515dd-785f-4bce-8395-e959a690a46e\/1oXwiZOnd68vt5jamNuOx1w0TPaAQeASKHjTfOtV.jpeg\",\"title\":\"Blessing Enofe's Profile\",\"url\":\"https:\/\/linkedin.com\/in\/blessing-enofe-577bb7ab\",\"altText\":\"Blessing Enofe Headshot photo\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/6fbe541e-3cfa-4b45-92da-20c4c95484e5\/29wmi0yQFO3LSXshye6frcgYGycsyT5D6W4CicY8.jpeg\",\"title\":\"Luvlybee's Multidimensional Services\",\"url\":\"https:\/\/linktr.ee\/luvlybee\",\"altText\":\"Luvlybee's Services logo \"}]}","{\"type\":\"text\",\"header\":\"ABOUT BLESSING \",\"data\":[{\"localHTML\":\"<p>Blessing Eseosa Enofe is a multi-talented lady with a life vision\/call to sustainably help recognise and develop potentials to the fullest, to the glory of God. She currently works towards this by enlightening minds.<\/p><p>Career wise, she helps promising personal and business brands to creatively tell their stories, captivate their audience and earn their trust. So that they willingly take action and become returning clients\/customers. Her career path is Digital Media, Creative and Health Communications.<\/p><p>On the side, she manages Luvlybee's Multidimensional Services - a sustainable social business venture that provides affordable freelance digital creative services for personal and business branding to increase productivity.<\/p><p>With Luvlybee's Services, she helps brands tell their stories through digital creative communications (Creative content\/copywriting, Comics, Animations, etc.) so that they can gain their target audience's trust, to make them become willing clients.<\/p><p>She also advocates for the causes she is passionate about (Self Discovery, Personal Development, Child Development, Women Empowerment, Health, Christian Lifestyle etc.) through her blogs and social media platforms.<\/p><p>A Healthy Eating, Nutrition, and Weight Loss Communications Enthusiast and a Humanitarian, she is all about making positive impact.<\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Let's Work Together\",\"url\":\"https:\/\/luvlybeeservices.disha.page\"},{\"title\":\"My Writing Portfolio\",\"url\":\"https:\/\/blessingenofe.journoportfolio.com\/\"},{\"title\":\"My Creative Portfolio\",\"url\":\"https:\/\/www.behance.net\/blessingenofe\/projects\/\"},{\"title\":\"Luvlybee's Personal Growth Blog \",\"url\":\"https:\/\/luvlybeelive.blogspot.com\/\"},{\"title\":\"Luvlybee's Nutrition and Health Blog\",\"url\":\"https:\/\/luvlybee2015.wordpress.com\/\"},{\"title\":\"The Talk With Chichi Series\",\"url\":\"https:\/\/youtube.com\/playlist?list=PLTDtUf_nPkA3CiDKjntncTfYeNBjHmv8k\/\"},{\"title\":\"Give To Support Luvlybee's Ventures\",\"url\":\"https:\/\/barter.me\/luvlybeeservices?currency=USD\"},{\"title\":\"Other Links\",\"url\":\"https:\/\/linktr.ee\/luvlybee\/\"}]}","{\"type\":\"video\",\"header\":\"The Talk With Chichi Series\",\"subheader\":\"Chichi is known for her insightful and inspirational talks. Everyone who comes in contact with her always learns a thing or more that are beneficial to their personal growth and development in all areas of their lives.\\n\\nJoin her in the TALK WITH CHICHI as she shares her opinions and insights centered around Self discovery; personal growth and development; and the Christian lifestyle.\\n\\n\\nStay blessed! \ud83d\udc9c\\n\\nView the series on youtube. The playlist link is listed above. Enjoy!\",\"data\":[{\"url\":\"https:\/\/www.youtube.com\/embed\/fVH3fM2wGpE\"}]}"],"settings":"{\"profileImage\":\"https:\/\/content.disha.ng\/pages\/88472268-a104-42aa-92d2-483e7324c1a7\/sxZgtDX4j9CPTr7eAnDtsfShuFUL7pMsR6AP4DGs.jpg\",\"pageTitle\":\"BLESSING E. ENOFE \",\"bio\":\"Multihyphenate Digital Creative Communicator||Storyteller|SEO Content\/ UX Writer|Content Marketer|Direct Response-Conversion Copywriter|Development Advocate|\u2728I creatively help enlighten minds.\",\"userStatus\":\"newUser\",\"socialLink\":[{\"id\":\"Facebook\",\"label\":\"facebook\",\"urlPrefix\":\"www.facebook.com\/\",\"value\":\"luvlybeelive\"},{\"id\":\"Instagram\",\"label\":\"instagram\",\"urlPrefix\":\"www.instagram.com\/\",\"value\":\"luvlybee_live\"},{\"id\":\"YouTube\",\"label\":\"youtube\",\"urlPrefix\":\"www.youtube.com\/\",\"value\":\"channelUCsJf0vTaFsz5tGE1GIz0FDg\"},{\"id\":\"LinkedIn\",\"label\":\"linkedin\",\"urlPrefix\":\"\",\"value\":\"https:\/\/linkedin.com\/in\/blessing-enofe\"},{\"id\":\"Tiktok\",\"label\":\"tiktok\",\"urlPrefix\":\"www.tiktok.com\/@\",\"value\":\"luvlybee_\"}],\"setTheme\":{\"selectedFont\":\"font-modern\",\"selectedColor\":\"disha-theme-purple-gradient\",\"selectedBorder\":\"border-normal\",\"selectedEdge\":\"edgeEnabled\",\"selectedBackground\":\"background-dark\",\"selectedBrand\":\"brandEnabled\",\"toggleVisitorsBg\":true},\"setScripts\":{\"googleAnalytics\":\"\",\"facebookPixels\":\"\"},\"tippings\":[{\"id\":\"Barter\",\"label\":\"barter\",\"urlPrefix\":\"https:\/\/barter.me\/\",\"value\":\"luvlybeeservices?currency=USD\"}]}","currency":null,"country":null,"industry":"[\"Personal Brand\"]","is_discoverable":1,"is_payment_on":1,"locale":"en","rave_islive":0,"rave_keys":null,"created_on":"2020-06-24T18:53:42.000000Z","updated_on":"2022-07-05T11:41:34.000000Z"}