{"status":"success","username":"bmg","page_id":29931,"firstname":"The Bible Marathon ","subscription":"{\"status\":\"free\",\"expiration_date\":null,\"can_trial\":true}","elements":["{\"type\":\"text\",\"header\":\"Welcome \ud83c\udf89\",\"data\":[{\"localHTML\":\"<p>Hi there, welcome to Bible Marathon. It's lovely to have you here.<\/p><p>Here we're all about growing in the word of God as believers, studying, praying and defending the Faith. We aim to help Christians grow deeper and more effective in their Faith. Hopefully, our goal aligns with yours. If it does, do join us on this holy mission.<\/p><ul><li><p>Join us <strong>every Sunday by 8:30PM WAT | 2:30PM EST on <a href=\\\"https:\/\/us02web.zoom.us\/j\/4010004010\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">Zoom<\/a>, <a href=\\\"https:\/\/bmg-live.mixlr.com\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">Mixlr<\/a> or <a href=\\\"https:\/\/www.youtube.com\/@bmg.global\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">YouTube<\/a><\/strong> for <strong>Healthy Instructions In Truth (HIIT)<\/strong> sessions. Here, we help people understand more about the doctrines of the Christian faith, how to defend it, how to exercise it, and create room for vulnerability.<\/p><\/li><li><p>Join us <strong>every Friday by 9:00PM WAT | 3:00PM EST on <a href=\\\"https:\/\/us02web.zoom.us\/j\/4010004010\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">Zoom<\/a>, <a href=\\\"https:\/\/bmg-live.mixlr.com\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">Mixlr<\/a> or <a href=\\\"https:\/\/www.youtube.com\/@bmg.global\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">YouTube<\/a> <\/strong>for<strong> WORD DINNER<\/strong>, where we carry out in depth study of different books of the Bible chapter by chapter.<\/p><\/li><li><p>Also on Fridays by <strong>8:30PM WAT | 2:30PM EST<\/strong>, <strong>we pray together for 30 minutes on <a href=\\\"https:\/\/bmg-live.mixlr.com\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">Mixlr<\/a><\/strong>. We call it <strong>CARDIO<\/strong> time.<\/p><\/li><\/ul><p>Got Questions?<\/p><p>Send us a <a href=\\\"bmglive4@gmail.com\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">mail<\/a>(bmglive4@gmail.com) or <a href=\\\"https:\/\/www.instagram.com\/bmg.global\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">DM<\/a> on Instagram<\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Check out the Bible Marathon Podcast \ud83c\udf99\ufe0f\",\"url\":\"https:\/\/linktr.ee\/bmgpod\"},{\"title\":\"Daily Gospills - (A \\\"gospel pill\\\" a day keeps the devil away)\",\"url\":\"https:\/\/www.youtube.com\/@bmg.global\/shorts\"},{\"title\":\"BMG's Youtube Page\",\"url\":\"https:\/\/www.youtube.com\/@bmg.global\"},{\"title\":\"BMG's Zoom Link\",\"url\":\"https:\/\/us02web.zoom.us\/j\/4010004010\"},{\"title\":\"BMG's Instagram Page\",\"url\":\"https:\/\/www.instagram.com\/bmg.global\"},{\"title\":\"Do you want to be an active part of Bible Marathon Group? Just fill this form\",\"url\":\"https:\/\/bit.ly\/bmgknows\"},{\"title\":\"Subscribe to our Newsletter\",\"url\":\"http:\/\/eepurl.com\/hwQdZr\"},{\"title\":\"We'd love to hear your testimonies. Send them in!\",\"url\":\"http:\/\/bit.ly\/bmgtestimony\"}]}","{\"type\":\"video\",\"header\":\"Rightly Dividing on YouTube \",\"subheader\":\"Rightly dividing is all about exercising those bible interpretation muscles. Bringing the true and correct interpretation of scriptures to the forefront for our edification \",\"data\":[{\"url\":\"https:\/\/www.youtube.com\/embed\/bfQpSpKaYK4\"}]}","{\"type\":\"text\",\"header\":\"THE GOOD NEWS\",\"data\":[{\"localHTML\":\"<p>The very best news you could ever hear in this life is the one about the next one. If you knew you could live forever, how much would you be willing to pay? Thankfully, you might not have to.<\/p><p>The good news is that God, the most holy judge of all the world, put the punishment and judgment we deserve on His one and only Son, Jesus Christ. He took upon Himself willfully all the sin and grief of humanity and received the just reward.<\/p><p>What does that mean for us sinners? After all we are the ones who truly deserve God's just punishment. Well, the good news is that anyone of us who trusts in what Jesus did on their behalf will be forgiven, cleansed, and made acceptable to God without works. God will give them His spirit to live in them as a guarantee that Jesus will return for them, or will be raised from the dead.<\/p><p><\/p>\"}]}"],"settings":"{\"profileImage\":\"https:\/\/content.disha.ng\/pages\/8e6994c5-4450-49e2-88e5-675e05366cfa\/LJJV7jJUtbEjynoNJRRGTiMBvmfiuAELQS0hNLbN.jpg\",\"pageTitle\":\"The Bible Marathon Group\",\"phoneNumber\":\"\",\"bio\":\"The Bible Marathon Group is a community of Christian Believers devoted to the study of the Bible and all-round spiritual growth. \\n\\nWe vulnerably approach answers about the faith, while paying strict attention to what God says in scripture.\",\"socialLink\":[{\"id\":\"Instagram\",\"label\":\"instagram\",\"urlPrefix\":\"www.instagram.com\/\",\"value\":\"bmg.global\"},{\"id\":\"Email\",\"label\":\"email\",\"urlPrefix\":\"www.email.com\/\",\"value\":\"bmglive4@gmail.com \"},{\"id\":\"Twitter\",\"label\":\"twitter\",\"urlPrefix\":\"www.twitter.com\/\",\"value\":\"bmg_global\"},{\"id\":\"YouTube\",\"label\":\"youtube\",\"urlPrefix\":\"www.youtube.com\/\",\"value\":\"bmg.global\"}],\"setTheme\":{\"selectedFont\":\"font-lively\",\"selectedColor\":\"disha-theme-disha\",\"selectedBorder\":\"border-rounded\",\"selectedEdge\":\"edgeEnabled\",\"selectedBackground\":\"background-light\",\"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":"2022-03-02T15:39:24.000000Z","updated_on":"2023-10-29T20:43:04.000000Z"}