{"status":"success","username":"ba","page_id":288,"firstname":"Blessing","subscription":"{\"status\":\"pro\",\"card_status\":true,\"can_trial\":false}","elements":["{\"type\":\"button\",\"data\":[{\"title\":\"subscribe: unbranded conversations + letters\",\"url\":\"https:\/\/substack.com\/@blessingabeng\"},{\"title\":\"Get my free ebooks\",\"url\":\"http:\/\/blessingabeng.com\/free-ebooks\/\"},{\"title\":\"Listen to my podcast\",\"url\":\"https:\/\/anchor.fm\/blessingabeng\"},{\"title\":\"Get my press kit\",\"url\":\"http:\/\/blessingabeng.com\/press-kit\/\"},{\"title\":\"Get Letters from Me (BA Letters)\",\"url\":\"http:\/\/blessingabeng.com\/ba-tribe\/\"},{\"title\":\"Subscribe to my LinkedIn newsletter: unbranded\",\"url\":\"https:\/\/www.linkedin.com\/pulse\/unbranded-personal-letter-you-blessing-abeng\/?trackingId=53Ld%2BIvzTMWNOezWmhajQg%3D%3D\"},{\"title\":\"Watch my I4G documentary: Finding Tech Against all Odds\",\"url\":\"https:\/\/www.youtube.com\/watch?v=Xb8e3T8pVDM\"},{\"title\":\"101+ Tools to Make Your Digital Life Easier\",\"url\":\"http:\/\/blessingabeng.com\/product\/101-digital-tools\/\"},{\"title\":\"Buy \\\"My Minimalist Wedding\\\" ebook\",\"url\":\"http:\/\/blessingabeng.com\/product\/my-minimalist-wedding\/\"},{\"title\":\"Read the I4G 2022 Impact Report\",\"url\":\"https:\/\/bit.ly\/I4G-ImpactReport2022\"},{\"title\":\"au revoir I4G: hello new adventure \",\"url\":\"https:\/\/blessingabeng.substack.com\/p\/au-revoir-i4g-hello-new-adventure\"}]}","{\"type\":\"video\",\"header\":\"15 minutes with Seth\",\"subheader\":\"\",\"data\":[{\"url\":\"https:\/\/www.youtube.com\/embed\/p_rawPNakxU\"}]}","{\"type\":\"text\",\"header\":\"Get to know me \",\"data\":[{\"localHTML\":\"<p>I use branding and communications to help creators identify their value, identity, and unique point of view. I help people build brands they love and tell better stories to help them communicate better with their team, target audience, partners, and investors.<\/p><p><strong>Clientele<\/strong><\/p><p><a href=\\\"https:\/\/www.africanallianceplc.com\/\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">African Alliance Insurance<\/a><br><a href=\\\"https:\/\/lcafilmfest.com\/\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">Lights Camera Africa<\/a><br><a href=\\\"https:\/\/www.darkandlovely.co.za\/\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">Dark and Lovely <\/a><br><a href=\\\"https:\/\/www.hbng.com\/\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">Heritage Bank<\/a><br><a href=\\\"http:\/\/lemighariokwu.com\/\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">Lemi Ghariokwu<\/a><br><a href=\\\"http:\/\/victorehi.com\/\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">Victor Ehikhamenor<\/a><br><a href=\\\"http:\/\/blessingabeng.com\/clients\/\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">and many others<\/a><\/p>\"}]}"],"settings":"{\"profileImage\":\"https:\/\/content.disha.ng\/pages\/f7d3671d-c42a-41fd-8d9d-0f3884642dc3\/UaukwpDKODRZZBYBcXstwO6GE9Ui4zN4JJpIEdSP.jpeg\",\"pageTitle\":\"Blessing Abeng\",\"bio\":\"A brand & comms documenting my thoughts, learnings and experience online to help creators who need it. Catalyst. Muse. Welcome to my  secondary home base with every relevant link you need to get to know me better and get value.\",\"userStatus\":\"newUser\",\"socialLink\":[{\"id\":\"Twitter\",\"label\":\"twitter\",\"urlPrefix\":\"www.twitter.com\/\",\"value\":\"blessinabeng_\"},{\"id\":\"LinkedIn\",\"label\":\"linkedin\",\"urlPrefix\":\"https:\/\/\",\"value\":\"blessingabeng\"},{\"id\":\"Envelope\",\"label\":\"envelope\",\"urlPrefix\":\"www.envelope.com\/\",\"value\":\"adminblessingabeng.com\"},{\"id\":\"Instagram\",\"label\":\"instagram\",\"urlPrefix\":\"www.instagram.com\/\",\"value\":\"blessinabeng_\"}],\"setTheme\":{\"selectedFont\":\"font-simple\",\"selectedColor\":\"disha-theme-default\",\"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":"","created_on":"2019-09-26T19:47:40.000000Z","updated_on":"2024-04-22T01:00:13.000000Z"}