{"status":"success","username":"rosiemar","page_id":33642,"firstname":"Nwanguma Rosemary chinonso","subscription":"{\"status\":\"free\",\"expiration_date\":null,\"can_trial\":true}","elements":["{\"type\":\"text\",\"header\":\"Welcome \ud83c\udf89\",\"data\":[{\"localHTML\":\"<p>On may 2022, i stumbled upon a friend's post on whatsapp on how to make money online. I decided to do some digging and research on this  online business model that turns people into millionaires. After much digging and research, i was convinced beyond reasonable doubt that this business model throughly works.<\/p><p>So on june 15th, 2022, i decided to take a leap of faith and I paid for this course and since then the rest has been history.<\/p><p>I know many of you are curious to know about this business model that can make you 6 to 7 figures weekly. This business model is called affiliate marketing.<\/p><p>Check out the testimonials below.<\/p><p>P.s: This people didn't have any tech skills or knowledge before taking this course.<\/p>\"}]}","{\"type\":\"video\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"url\":\"https:\/\/www.youtube.com\/embed\/ev77oroy6-Y\"}]}","{\"type\":\"text\",\"header\":\"\",\"data\":[{\"localHTML\":\"<p>I know most of you really need a breakthrough badly. I have an amazing offer for you.<\/p><ul><li><p>A course that contains high income skill that will help you transform your financial life for good.<\/p><\/li><li><p>A free training session on how to become an affiliate marketing professional.<\/p><\/li><li><p>Access to my mentorship group.<\/p><\/li><li><p>An hour free consultation on online business opportunities.<\/p><\/li><li><p>Access to my premium content on money making, positive lifestyle and development.<\/p><\/li><li><p>Access to my resource library worth 150,000 naira.<\/p><\/li><\/ul>\"}]}"],"settings":"{\"profileImage\":\"https:\/\/content.disha.ng\/pages\/943889a0-3c58-4eb8-b760-849499ada7b7\/je72Il7Jn6eGiwxUFWTrJqa57LEVpyiIgx4yLUMl.jpg\",\"pageTitle\":\"NwangumaRosemary( changing lives)\",\"bio\":\"Welcome! My name is Nwanguma Rosemary. I am a digital entrepreneur and an online business consultant. Just like you, i have sought for ways to make money online until I came across a perfect business model that works for anybody who is willing and determined. With this being said, my main goal is to help you kickstart your journey towards financial independence by leveraging or maximizing the online space as a tool to achieve it. I am very sure most of you are wondering which Business model is it that assures financial independence. To know more about this business model, you are free to go through my page.\",\"userStatus\":\"newUser\",\"socialLink\":[{\"id\":\"Instagram\",\"label\":\"instagram\",\"urlPrefix\":\"www.instagram.com\/\",\"value\":\"Codedrosie\"},{\"id\":\"Twitter\",\"label\":\"twitter\",\"urlPrefix\":\"www.twitter.com\/\",\"value\":\"RosemaryNwangu1\"},{\"id\":\"Whatsapp\",\"label\":\"whatsapp\",\"urlPrefix\":\"www.whatsapp.com\/\",\"value\":\"2349139087921\"},{\"id\":\"Email\",\"label\":\"email\",\"urlPrefix\":\"www.email.com\/\",\"value\":\"nwangumar@gmail.com\"}],\"setTheme\":{\"selectedFont\":\"font-simple\",\"selectedColor\":\"disha-theme-default\",\"selectedBorder\":\"border-default\",\"selectedEdge\":\"edgeEnabled\",\"selectedBackground\":\"background-light\",\"selectedBrand\":\"brandEnabled\"},\"setScripts\":{\"googleAnalytics\":\"\",\"facebookPixels\":\"\"}}","currency":"NGN","country":"NG","industry":"[\"Education\",\"Content creation\",\"Technology\",\"Blogging\"]","is_discoverable":1,"is_payment_on":1,"has_products":false,"locale":"en","rave_islive":1,"rave_keys":"","created_on":"2022-07-12T19:39:58.000000Z","updated_on":"2022-07-16T14:12:43.000000Z"}