{"status":"success","username":"asydarlyn","page_id":13171,"firstname":"Asitonka Aggrey-Abah","subscription":"{\"status\":\"free\",\"expiration_date\":null,\"can_trial\":true}","elements":["{\"type\":\"button\",\"data\":[{\"title\":\"SUBSCRIBE to my YouTube channel \",\"url\":\"https:\/\/www.youtube.com\/c\/AsyDarlyn\"},{\"title\":\"LISTEN to my Podcast (NigerianWeddingPlanning)\",\"url\":\"http:\/\/anchor.fm\/asydarlyn\"},{\"title\":\"Instagram (Asy Darlyn)\",\"url\":\"https:\/\/www.instagram.com\/asydarlyn\"},{\"title\":\"Instagram (3003events)\",\"url\":\"http:\/\/www.instagram.com\/3003events\"},{\"title\":\"Instagram (NigerianWeddingPlanningPodcast)\",\"url\":\"https:\/\/www.instagram.com\/nigerianweddingplanningpodcast\"}]}","{\"type\":\"card\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/51798885-55dc-427a-8e1e-f28cba098f55\/5wVeyIf86NrP0blc9e9bU9V2vtNNQgrfb38biFwp.jpeg\",\"title\":\"Welcome \",\"altText\":\"The CEO of 3003 Events. Asitonka Aggrey-Abah\",\"url\":\"\"}]}","{\"type\":\"list\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/2ab3c3d6-f691-4167-a96d-ab244c8b70c3\/CpgAfx9TlWee8DDBTcHZnmGITtN1sM7ydrtXmUnm.jpeg\",\"title\":\"Asitonka Aggrey-Abah aka Asy Darlyn\",\"desc\":\"Jeremiah 29:11\",\"altText\":\"Meet The CEO of 3003 Events, Asitonka Aggrey-Abah\",\"url\":\"http:\/\/www.instagram.com\/asydarlyn\"}]}","{\"type\":\"list\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/c2e45e15-2f2a-4cdd-85e2-3b41fd55e33e\/GLEShsUxEw844OE16V0KTpA35nc6U413tyUZlCMQ.jpeg\",\"title\":\"Nigerian Wedding Planning podcast with Asy Darlyn\",\"desc\":\"The first ever Nigerian wedding podcast dedicated to discussing all the tips and strategies it takes to plan a successful Nigerian wedding. I\u2019d also feature behind the scenes details and interviews with the finest minds in the Nigerian event industry.\",\"altText\":\"Nigerian wedding planning podcast with Asy Darlyn. Available on Apple, anchor google play and Spotify \",\"url\":\"http:\/\/anchor.fm\/asydarlyn\"}]}","{\"type\":\"list\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/6befcb30-ce51-40d4-ae18-050d8bfa7dd3\/Q84SWh422Ny7IUYJ62Ela2GID1YqkcdpWxWzVYaf.jpeg\",\"title\":\"YouTube channel: Asy Darlyn\",\"desc\":\"Wedding planning and Lifestyle vlogs. \",\"altText\":\"YouTube channel Asy Darlyn. Subscribe \",\"url\":\"http:\/\/www.youtube.com\/c\/asydarlyn\"}]}","{\"type\":\"card\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/1bf01289-39c4-44f1-84e9-6e6da8623a39\/0i63gJQO8j1Ch3XIwSUweLuXd2QFdQmskPdtmJJP.jpeg\",\"title\":\"\",\"altText\":\"3003 Events logo\",\"url\":\"http:\/\/www.instagram.com\/3003events\"}]}","{\"type\":\"text\",\"header\":\"About 3003 Events\",\"data\":[{\"localHTML\":\"<p>3003 Events is a luxury event planning and management company. We specialize in planning beautiful weddings and managing corporate events. <br><br>Founded in 2015, We\u2019ve planned hundreds of events for a wide array of clients. From micro weddings, elopements and intimate parties to large weddings, gatherings and government functions, 3003 Events has got you covered.<\/p><p>Newly engaged?<br>Do you have an event coming up? <br>Do you know a friend that needs an event planner? <br>Let 3003 Events can handle it for you. We love to create beautiful memories for our clients.<\/p><p>You can contact us on our instagram page @3003events or send an email to info3003events@gmail.com <br><\/p><p>We\u2019d be glad to plan your special day with you as you begin your journey to HAPPILY EVER AFTER. <\/p>\"}]}","{\"type\":\"card\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/6fc074b2-5878-4352-b789-fa063264d509\/Z6xYF0F7qufKLzzuav4VfVRCGCtMqF9TuaBbwPKx.jpeg\",\"title\":\"\",\"altText\":\"Wedding rings on a bouquet, this event took place in Warri, Delta state. Wedding planned by 3003 events\",\"url\":\"\"}]}","{\"type\":\"card\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/d07b32f0-0eb4-4d19-ab11-c56ba33bc3ec\/To4KS23f7AiAxJjTDkJ1izDLv4VgloCj27PepTa9.jpeg\",\"title\":\"ATTENTION TO DETAIL\",\"altText\":\"\",\"url\":\"\"}]}","{\"type\":\"video\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"url\":\"https:\/\/www.youtube.com\/embed\/eVlpZjehhTA\"},{\"url\":\"https:\/\/www.youtube.com\/embed\/g66YQiubAvo\"},{\"url\":\"https:\/\/www.youtube.com\/embed\/qRtaCuL28Rg\"},{\"url\":\"https:\/\/www.youtube.com\/embed\/fqx8jfgqgnE\"}]}","{\"type\":\"card\",\"header\":\"Micro weddings in Nigeria : Our new normal\",\"subheader\":\" \",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/534011e5-e3a5-4739-ae80-42ef9003824e\/gmwRcMxIws9zSdYMXOrR0aIHlN2q2JiY4Xpky2uL.jpeg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"}]}","{\"type\":\"card\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/dbed21cf-a01d-4b19-b367-56666727a384\/sVM6GBteR40fjxVobmSeeW44mHFuD8HlKJCsBfXe.jpeg\",\"title\":\"CHOOSE THE RIGHT BRIDESMAIDS \",\"altText\":\"Bride and her friends \",\"url\":\"\"}]}","{\"type\":\"card\",\"header\":\"Luxury traditional wedding in Afikpo, Ebonyi state.\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/d9fbcd24-6fff-42d1-bf01-870fdf8c703c\/e3WXs9lqlQNv8yFPPdnmBxyAvridL8lQoqqtFfl4.jpeg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"}]}","{\"type\":\"card\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/935d0832-07d2-48af-8c49-c6292027ba2c\/DhM1NTAlLmYqlKKbPYFdvYlrHXsrmzgSfQK5qcSE.jpeg\",\"title\":\"We offer Premium vendor selection \",\"altText\":\"Morning preparations for a bride\",\"url\":\"\"}]}","{\"type\":\"card\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/5387df39-97d6-4f6a-be57-1bb601a1b204\/JOk1DDR4S931lj6JFk9BbFWReE8YlyHYUdeGHFSC.jpeg\",\"title\":\"GREAT FEEDBACK!! Always \ud83d\udc83\ud83c\udffd\",\"altText\":\"Beautiful couple with the event planner \",\"url\":\"\"}]}","{\"type\":\"text\",\"header\":\"\",\"data\":[{\"localHTML\":\"<p>CONTACT: Please send us an email,<\/p><p>For Wedding\/Event planning: info3003events@gmail.com<\/p><p>For YouTube or Podcast PR: asydarlyn.abah@gmail.com<\/p><p>Cheers!!<\/p>\"}]}"],"settings":"{\"profileImage\":\"https:\/\/content.disha.ng\/pages\/79f2a231-e4c3-4207-adfc-00ca71cb76e2\/mIuS0xM34lfPU6PwprIQEqUNDM4FYRjTck0i6Drv.jpeg\",\"pageTitle\":\"Asitonka Aggrey-Abah\",\"bio\":\"Wedding planner | Youtuber | Podcaster\\n\",\"userStatus\":\"newUser\",\"socialLink\":[{\"id\":\"Instagram\",\"label\":\"instagram\",\"urlPrefix\":\"www.instagram.com\/\",\"value\":\"asydarlyn\"},{\"id\":\"YouTube\",\"label\":\"youtube\",\"urlPrefix\":\"www.youtube.com\/\",\"value\":\"c\/AsyDarlyn\"},{\"id\":\"Apple\",\"label\":\"apple\",\"urlPrefix\":\"www.apple.com\/\",\"value\":\"ng\/podcast\/nigerian-wedding-planning-with-asy-darlyn\/id1520522973\"},{\"id\":\"Facebook\",\"label\":\"facebook\",\"urlPrefix\":\"www.facebook.com\/\",\"value\":\"3003events\"},{\"id\":\"Email\",\"label\":\"email\",\"urlPrefix\":\"www.email.com\/\",\"value\":\"asydarlyn.abah@gmail.com\"}],\"setTheme\":{\"selectedFont\":\"font-bold\",\"selectedColor\":\"disha-theme-default\",\"selectedBorder\":\"border-rounded\",\"selectedEdge\":\"edgeDisabled\",\"selectedBackground\":\"background-dark\",\"selectedBrand\":\"brandEnabled\",\"toggleVisitorsBg\":false},\"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":"2020-07-19T09:48:16.000000Z","updated_on":"2021-11-23T17:10:16.000000Z"}