{"status":"success","username":"sanya","page_id":11689,"firstname":"Agunbiade Sanya","subscription":"{\"status\":\"free\",\"expiration_date\":null}","created_on":"2020-07-03T07:35:53.000000Z","updated_on":"2020-09-28T15:36:30.000000Z","elements":["{\"type\":\"text\",\"header\":\"TRADERA CAN CHANGE YOUR LIFE\",\"data\":[{\"localHTML\":\"<p>Welcome,<\/p><p>Tradera is an online platform where you can make money, even as an amateur on the internet<\/p><p>Tradera focuses on Forex Education for its members and also allow you to earn through its MLM aspect, where you get paid by promoting the program to other people.<\/p><pre><code>You are not expected to trade in Forex. The Forex Aspect is only reserved for people that are interested in that.<\/code><\/pre><p>\ud83c\udf39 In Tradera, with just an entry fee of $99 or N40,000, you can make minimum of $500\/month.<\/p><p>But don't be scared, I am going to give you cash support of $20 or N10, 000 if you read to the end and join our team.<\/p><pre><code>ARE YOU SCARED OF REFERRAL PROGRAMS? We got your back!<\/code><\/pre><p>\ud83c\udf39 Here in our team, we have a marketing structure that allows every member to grow to higher levels without stress. You don't have to bother yourself with downlines as we will teach you how to do that.<\/p><p>One way through which we get fast downlines in our team is by offering CASH support to new members. With this, people are motivated to join our team and we all grow fast.<\/p><p>So even if you join, we will also support your own referrals with cash so they can join on time and you can grow fast.<\/p><pre><code>HOW YOU EARN<\/code><\/pre><p>1st level - FREE FOREX EDUCATION<\/p><p>2nd level - You get $500 monthly<\/p><p>3rd level - You get $1000 monthly.<\/p><p>4th level: $2000 monthly<\/p><p>5th level - $5000 monthly<\/p><p>\ud83c\udf39 It's easy to achieve when you join an active team like ours where all you have to do is post our marketing materials on your social media platforms and you are good to go.<\/p><p>Now is the best time to join as we are currently running an aggressive marketing across social media.<\/p><p>And when you choose to join our team, I'll personally transfer $20 or N10,000 cash back to you, depending on the time you are coming in.<\/p><pre><code>CLICK LINK BELOW TO JOIN THE GROUP AND SEND ME A DM<\/code><\/pre><p><a href=\\\"https:\/\/chat.whatsapp.com\/IfBTCpAtszh7ylquhVkWIT\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">https:\/\/chat.whatsapp.com\/IfBTCpAtszh7ylquhVkWIT<\/a><\/p><p>or WhatsApp: +2348038606260<\/p><p><\/p><pre><code>TRADERA COMPENSATION PLAN <\/code><\/pre><p>When you join the program, to begin your journey of making money, you are expected to invite 3 people (these 3 people make up your 3 legs and every other people that come in under them will be in either your Leg 1, Leg 2 or 3)<\/p><p>After you invite 3 people, you will get to the level of FOUNDER, where the benefit is just FOREX EDUCATION.<\/p><p>The 1st 3 people you invite are also expected to invite 3 each. To hit the level of KNIGHT where you get $500\/month, you must fulfill the 4\/4\/2 mark. That is: Your 1st leg must have 4 people (including your 1st invitee) Your 2nd leg must have 4 people including your 2nd invitee Your 3rd leg must have 2 people including your 3rd invitee.<\/p><p>Once that is complete. You hit Knight and start getting paid $500<\/p><p>To hit NOBLE, which is the next level you must have 10\/10\/5. But note that the number of people you have in Knight will also count in noble, it is not like you have to start looking for NEW 10 people.<\/p><p>It's at this level that you receive $1000\/month<\/p><pre><code>JOIN MY TEAM AND YOU'LL GET N10,000 CASH BACK<\/code><\/pre><p>SEND ME A DM after joining the group: <a href=\\\"https:\/\/chat.whatsapp.com\/IfBTCpAtszh7ylquhVkWIT\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">https:\/\/chat.whatsapp.com\/IfBTCpAtszh7ylquhVkWIT<\/a><\/p><p>or WhatsApp: 08038606260<\/p>\"}]}","{\"type\":\"card\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/fd37dbc5-530b-4499-b0a6-d94150e5f5e1\/i484Jd3MBQX3maAa6X8GlyctgB93pVEy02MaEf0a.jpeg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/695f023f-1fa5-4430-b7ce-05cf9fe8e46c\/A4jtYcIVb5HAZnMoSy6FpFSJNmNtjVu6KUdcJ3sQ.jpeg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/81c826b9-3987-4bfa-a816-6060a50b85a0\/FGuLxltY7jIXAz5YCCTf1y7sqCBzgil2tJo7CyJA.jpeg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/bd03c90d-1460-4d54-af4f-8036c924378c\/8uDU65BSaYCqWaG31g3Ohp5OAcxZQ8tpTGyHQZlJ.jpeg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"}]}","{\"type\":\"card\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/7e475c55-24f4-4164-829b-fbd27ea1559b\/7EO30L8V7XMiEAkCfrTJCWGa3afhmpxY8fnPNff0.jpeg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"}]}","{\"type\":\"text\",\"header\":\"\",\"data\":[{\"localHTML\":\"<p><strong>TRADERA COMPENSATION PLAN<\/strong> When you join the program, to begin your journey of making money, you are expected to invite 3 people (these 3 people make up your 3 legs and every other people that come in under them will be in either your Leg 1, Leg 2 or 3)<\/p><p>After you invite 3 people, you will get to the level of FOUNDER, where the benefit is just FOREX EDUCATION.<\/p><p>The 1st 3 people you invite are also expected to invite 3 each. To hit the level of KNIGHT where you get $500\/month, you must fulfill the 4\/4\/2 mark. That is: Your 1st leg must have 4 people (including your 1st invitee) Your 2nd leg must have 4 people including your 2nd invitee Your 3rd leg must have 2 people including your 3rd invitee.<\/p><p>Once that is complete. You hit Knight and start getting paid $500<\/p><p>To hit NOBLE, which is the next level you must have 10\/10\/5. But note that the number of people you have in Knight will also count in noble, it is not like you have to start looking for NEW 10 people.<\/p><p>It's at this level that you receive $1000\/month<\/p><p>JOIN MY TEAM AND YOU'LL GET N10,000 CASH BACK<\/p><p>SEND ME A DM after joining the group: <a href=\\\"https:\/\/chat.whatsapp.com\/KPHQhckbbHgH2BdUAJ3xBA?ref=dishapages\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">https:\/\/chat.whatsapp.com\/KPHQhckbbHgH2BdUAJ3xBA<\/a><\/p>\"}]}"],"settings":"{\"profileImage\":\"https:\/\/content.disha.ng\/pages\/1598be24-8192-4fd8-9d3f-c064a30f50e5\/zMh8UY0ydhLM9JYWQUs1uEh5Is5SPBFHJrkaX5HU.jpeg\",\"pageTitle\":\"Agunbiade Sanya\",\"bio\":\"   I am a Digital Marketer and Skill Acquisition Trainer\/Coach. \",\"userStatus\":\"newUser\",\"socialLink\":[{\"id\":\"Whatsapp\",\"label\":\"whatsapp\",\"urlPrefix\":\"www.whatsapp.com\/\",\"value\":\"2348038606260\"},{\"id\":\"Instagram\",\"label\":\"instagram\",\"urlPrefix\":\"www.instagram.com\/\",\"value\":\"softskills_ng\"},{\"id\":\"Email\",\"label\":\"email\",\"urlPrefix\":\"www.email.com\/\",\"value\":\"agunbiadesanya@gmail.com\"}],\"setTheme\":{\"selectedFont\":\"font-bold\",\"selectedColor\":\"disha-theme-red\",\"selectedBorder\":\"border-normal\",\"selectedEdge\":\"edgeEnabled\",\"selectedBackground\":\"background-light\",\"selectedBrand\":\"brandEnabled\"},\"setScripts\":{\"googleAnalytics\":\"\",\"facebookPixels\":\"<!-- Facebook Pixel Code -->\\n<script>\\n!function(f,b,e,v,n,t,s)\\n{if(f.fbq)return;n=f.fbq=function(){n.callMethod?\\nn.callMethod.apply(n,arguments):n.queue.push(arguments)};\\nif(!f._fbq)f._fbq=n;n.push=n;n.loaded=!0;n.version='2.0';\\nn.queue=[];t=b.createElement(e);t.async=!0;\\nt.src=v;s=b.getElementsByTagName(e)[0];\\ns.parentNode.insertBefore(t,s)}(window, document,'script',\\n'https:\/\/connect.facebook.net\/en_US\/fbevents.js');\\nfbq('init', '321622648877277');\\nfbq('track', 'PageView');\\n<\/script>\\n<noscript><img height=\\\"1\\\" width=\\\"1\\\" style=\\\"display:none\\\"\\nsrc=\\\"https:\/\/www.facebook.com\/tr?id=321622648877277&ev=PageView&noscript=1\\\"\\n\/><\/noscript>\\n<!-- End Facebook Pixel Code -->\"}}"}