{"status":"success","username":"peaceitimi","page_id":772,"firstname":"E","subscription":"{\"status\":\"pro\",\"card_status\":true,\"can_trial\":false}","elements":["{\"type\":\"button\",\"data\":[{\"title\":\"Get a credential from Google: Google Career Certificates\",\"url\":\"https:\/\/grow.google\/intl\/ssa-en\/google-career-certificates\/?utm_source=youtube&utm_medium=cpc&utm_campaign=GwG_SSA_Q2_Q3_2023_Influencer&utm_content=Peace_Nigeria\"},{\"title\":\"Watch my latest YouTube Video here\",\"url\":\"https:\/\/youtube.com\/peaceitimiofficial\"},{\"title\":\"Founders Connect Live in Lagos. Get your tickets now\",\"url\":\"http:\/\/Foundersconnect.xyz\/event\"},{\"title\":\"Subscribe to my weekly newsletter #WeStayLearning\",\"url\":\"https:\/\/www.getrevue.co\/profile\/peaceitimi\"},{\"title\":\"Send me questions to ask Sean Ellis\",\"url\":\"  https:\/\/forms.gle\/NycGQ1tjZZmc6h2Q7\"},{\"title\":\"Get my new ebook - Growth Hacks\",\"url\":\"https:\/\/selar.co\/growthhack\"}]}","{\"type\":\"text\",\"header\":\"\",\"data\":[{\"localHTML\":\"<p>I am passionate and committed to <strong>growing people and growing businesses.<\/strong><\/p><p><strong>Growing People<\/strong>: Coaching and teaching young people and entrepreneurs on transferable, digital literacy and business skills so that they could become better people, better leaders and better entrepreneurs.<\/p><p><strong>Growing Businesses<\/strong>: Ideating and implementing scalable data analytics, growth models, marketing and funnel optimization strategies for businesses in Africa.<\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Book a 1:1 Session (Lets talk about your Business, Marketing, Career or Life)\",\"url\":\"https:\/\/paystack.com\/pay\/60wpi\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Subscribe to My YouTube Channel\",\"url\":\"http:\/\/YouTube.com\/peaceitimiofficial?sub_confirmation=1\"},{\"title\":\"The Vulnerability Podcast\",\"url\":\"http:\/\/thevulnerabilitypodcast.disha.page\"},{\"title\":\"Founders Connect Podcast\",\"url\":\"https:\/\/anchor.fm\/founders-connect\"},{\"title\":\"Learn from me on Udemy\",\"url\":\"https:\/\/www.udemy.com\/user\/peace-itimi\/\"}]}","{\"type\":\"video\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"url\":\"https:\/\/www.youtube.com\/embed\/drDU8Zn7mnI\"}]}"],"settings":"{\"profileImage\":\"https:\/\/scontent.cdninstagram.com\/vp\/6b3cb9a29a9ee91da1144d6ac63880d6\/5E25D2AD\/t51.2885-19\/s150x150\/60735003_396056274337386_136506232604196864_n.jpg?_nc_ht=scontent.cdninstagram.com\",\"pageTitle\":\"P E A C E   I T I M I\",\"bio\":\"Director of Marketing & Content Creator\",\"userStatus\":\"newUser\",\"socialLink\":[{\"id\":\"YouTube\",\"label\":\"youtube\",\"urlPrefix\":\"www.youtube.com\/\",\"value\":\"peaceitimiofficial\"},{\"id\":\"LinkedIn\",\"label\":\"linkedin\",\"urlPrefix\":\"www.linkedin.com\/in\/\",\"value\":\"peaceitimi\"},{\"id\":\"Twitter\",\"label\":\"twitter\",\"urlPrefix\":\"www.twitter.com\/\",\"value\":\"peaceitimi\"},{\"id\":\"Email\",\"label\":\"email\",\"urlPrefix\":\"www.email.com\/\",\"value\":\"business@peaceitimi.com\"}],\"setTheme\":{\"selectedFont\":\"font-modern\",\"selectedColor\":\"disha-theme-red\",\"selectedBorder\":\"border-normal\",\"selectedEdge\":\"edgeEnabled\",\"selectedBackground\":\"background-dark\",\"selectedBrand\":\"brandDisabled\",\"toggleVisitorsBg\":false},\"setScripts\":{\"googleAnalytics\":\"\",\"facebookPixels\":\"\"}}","currency":null,"country":"GB","industry":"[\"Content creation\",\"Personal Brand\",\"Technology\"]","is_discoverable":1,"is_payment_on":1,"has_products":false,"locale":"en","rave_islive":0,"rave_keys":null,"created_on":"2019-10-10T16:14:50.000000Z","updated_on":"2023-10-02T13:00:26.000000Z"}