window.nitroFragments['f39aaa2f8981b16c9bd5534ac63035a6'] = {"isLazyLoaded":true,"content":"<section data-id="4bc78a9c" data-element_type="section" data-e-type="section" id="boxes-section" data-settings="{&quot;background_background&quot;:&quot;classic&quot;}" class="elementor-section elementor-top-section elementor-element elementor-element-4bc78a9c elementor-section-boxed elementor-section-height-default elementor-section-height-default nitro-lazy-render nlr-2" nitro-fragment-parent> <div class="elementor-container elementor-column-gap-default"> <div class="elementor-column elementor-col-33 elementor-top-column elementor-element elementor-element-2b61a609" data-id="2b61a609" data-element_type="column" data-e-type="column" data-settings="{&quot;background_background&quot;:&quot;classic&quot;}"> <div class="elementor-widget-wrap elementor-element-populated"> <section class="elementor-section elementor-inner-section elementor-element elementor-element-3b32cc57 elementor-section-height-min-height elementor-section-boxed elementor-section-height-default" data-id="3b32cc57" data-element_type="section" data-e-type="section" id="instagram-growth-below" data-settings="{&quot;background_background&quot;:&quot;classic&quot;}"> <div class="elementor-container elementor-column-gap-default"> <div class="elementor-column elementor-col-100 elementor-inner-column elementor-element elementor-element-1d2fef7a" data-id="1d2fef7a" data-element_type="column" data-e-type="column"> <div class="elementor-widget-wrap elementor-element-populated"> <div class="elementor-element elementor-element-a7647e8 elementor-widget elementor-widget-image" data-id="a7647e8" data-element_type="widget" data-e-type="widget" data-widget_type="image.default"> <div class="elementor-widget-container"> <img width="39" height="40" alt="A quote sign icon." title="quote-img | Path Social | Path Social" nitro-lazy-src="https://cdn-cdahj.nitrocdn.com/UpBIwlpZxVKaCSxNxPFyrgjxpDMdppJI/assets/images/optimized/rev-0576c4c/www.pathsocial.com/wp-content/uploads/2021/10/quote-img.png" class="attachment-full size-full wp-image-14608 nitro-lazy" decoding="async" nitro-lazy-empty id="MTg4NzoyNjk=-1" data-nitro-empty-id="MTg4NzoyNjk=-1" src="data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMzkgNDAiIHdpZHRoPSIzOSIgaGVpZ2h0PSI0MCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48L3N2Zz4=" /> </div> </div> <div class="elementor-element elementor-element-4b21bdb pera-box elementor-widget elementor-widget-text-editor" data-id="4b21bdb" data-element_type="widget" data-e-type="widget" data-widget_type="text-editor.default"> <div class="elementor-widget-container"> <p>Path Social uses an expert team and an AI targeting algorithm to find organic Instagram followers that are most likely to engage with your unique content and niche. Their growth suite may be the most disruptive service and technology we’ve seen in 2023.</p> </div> </div> <div class="elementor-element elementor-element-281e566c elementor-widget elementor-widget-image" data-id="281e566c" data-element_type="widget" data-e-type="widget" data-widget_type="image.default"> <div class="elementor-widget-container"> <img width="816" height="15" alt="Underline." sizes="(max-width: 816px) 100vw, 816px" title="border-img | Path Social | Path Social" nitro-lazy-srcset="https://cdn-cdahj.nitrocdn.com/UpBIwlpZxVKaCSxNxPFyrgjxpDMdppJI/assets/images/optimized/rev-0576c4c/www.pathsocial.com/wp-content/uploads/2021/10/border-img.png 816w, https://cdn-cdahj.nitrocdn.com/UpBIwlpZxVKaCSxNxPFyrgjxpDMdppJI/assets/images/optimized/rev-0576c4c/www.pathsocial.com/wp-content/uploads/2021/10/border-img-300x6.png 300w, https://cdn-cdahj.nitrocdn.com/UpBIwlpZxVKaCSxNxPFyrgjxpDMdppJI/assets/images/optimized/rev-0576c4c/www.pathsocial.com/wp-content/uploads/2021/10/border-img-768x14.png 768w" nitro-lazy-src="https://cdn-cdahj.nitrocdn.com/UpBIwlpZxVKaCSxNxPFyrgjxpDMdppJI/assets/images/optimized/rev-0576c4c/www.pathsocial.com/wp-content/uploads/2021/10/border-img.png" class="attachment-full size-full wp-image-14605 nitro-lazy" decoding="async" nitro-lazy-empty id="MTg5NTo1NTA=-1" data-nitro-empty-id="MTg5NTo1NTA=-1" src="data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgODE2IDE1IiB3aWR0aD0iODE2IiBoZWlnaHQ9IjE1IiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPjwvc3ZnPg==" /> </div> </div> <div class="elementor-element elementor-element-168ab4af other-languages-tech-news elementor-widget elementor-widget-image" data-id="168ab4af" data-element_type="widget" data-e-type="widget" data-widget_type="image.default"> <div class="elementor-widget-container"> <img width="85" height="40" alt="Forbes logo." title="forbes | Path Social | Path Social" nitro-lazy-src="https://cdn-cdahj.nitrocdn.com/UpBIwlpZxVKaCSxNxPFyrgjxpDMdppJI/assets/images/optimized/rev-0576c4c/www.pathsocial.com/wp-content/uploads/2021/08/forbes.png" class="attachment-full size-full wp-image-6340 nitro-lazy" decoding="async" nitro-lazy-empty id="MTg5OToyNTY=-1" data-nitro-empty-id="MTg5OToyNTY=-1" src="data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgODUgNDAiIHdpZHRoPSI4NSIgaGVpZ2h0PSI0MCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48L3N2Zz4=" /> </div> </div> </div> </div> </div> </section> </div> </div> <div class="elementor-column elementor-col-33 elementor-top-column elementor-element elementor-element-92a0f51" data-id="92a0f51" data-element_type="column" data-e-type="column" data-settings="{&quot;background_background&quot;:&quot;classic&quot;}"> <div class="elementor-widget-wrap elementor-element-populated"> <section class="elementor-section elementor-inner-section elementor-element elementor-element-102b4699 elementor-section-height-min-height elementor-section-boxed elementor-section-height-default" data-id="102b4699" data-element_type="section" data-e-type="section" id="instagram-growth-below" data-settings="{&quot;background_background&quot;:&quot;classic&quot;}"> <div class="elementor-container elementor-column-gap-default"> <div class="elementor-column elementor-col-100 elementor-inner-column elementor-element elementor-element-6d83514c" data-id="6d83514c" data-element_type="column" data-e-type="column"> <div class="elementor-widget-wrap elementor-element-populated"> <div class="elementor-element elementor-element-263aba90 elementor-widget elementor-widget-image" data-id="263aba90" data-element_type="widget" data-e-type="widget" data-widget_type="image.default"> <div class="elementor-widget-container"> <img width="39" height="40" alt="A quote sign icon." title="quote-img | Path Social | Path Social" nitro-lazy-src="https://cdn-cdahj.nitrocdn.com/UpBIwlpZxVKaCSxNxPFyrgjxpDMdppJI/assets/images/optimized/rev-0576c4c/www.pathsocial.com/wp-content/uploads/2021/10/quote-img.png" class="attachment-full size-full wp-image-14608 nitro-lazy" decoding="async" nitro-lazy-empty id="MTkxNToyNjk=-1" data-nitro-empty-id="MTkxNToyNjk=-1" src="data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMzkgNDAiIHdpZHRoPSIzOSIgaGVpZ2h0PSI0MCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48L3N2Zz4=" /> </div> </div> <div class="elementor-element elementor-element-205e45de pera-box elementor-widget elementor-widget-text-editor" data-id="205e45de" data-element_type="widget" data-e-type="widget" data-widget_type="text-editor.default"> <div class="elementor-widget-container"> Instagram growth is about building a community who will engage with your content, product, or service for years to come. Path Social is one of the leading innovators to help businesses architect those communities in a way that’s personalized to their brand voice. </div> </div> <div class="elementor-element elementor-element-33047e95 elementor-widget elementor-widget-image" data-id="33047e95" data-element_type="widget" data-e-type="widget" data-widget_type="image.default"> <div class="elementor-widget-container"> <img width="816" height="15" alt="Underline." sizes="(max-width: 816px) 100vw, 816px" title="border-img | Path Social | Path Social" nitro-lazy-srcset="https://cdn-cdahj.nitrocdn.com/UpBIwlpZxVKaCSxNxPFyrgjxpDMdppJI/assets/images/optimized/rev-0576c4c/www.pathsocial.com/wp-content/uploads/2021/10/border-img.png 816w, https://cdn-cdahj.nitrocdn.com/UpBIwlpZxVKaCSxNxPFyrgjxpDMdppJI/assets/images/optimized/rev-0576c4c/www.pathsocial.com/wp-content/uploads/2021/10/border-img-300x6.png 300w, https://cdn-cdahj.nitrocdn.com/UpBIwlpZxVKaCSxNxPFyrgjxpDMdppJI/assets/images/optimized/rev-0576c4c/www.pathsocial.com/wp-content/uploads/2021/10/border-img-768x14.png 768w" nitro-lazy-src="https://cdn-cdahj.nitrocdn.com/UpBIwlpZxVKaCSxNxPFyrgjxpDMdppJI/assets/images/optimized/rev-0576c4c/www.pathsocial.com/wp-content/uploads/2021/10/border-img.png" class="attachment-full size-full wp-image-14605 nitro-lazy" decoding="async" nitro-lazy-empty id="MTkyMzo1NTA=-1" data-nitro-empty-id="MTkyMzo1NTA=-1" src="data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgODE2IDE1IiB3aWR0aD0iODE2IiBoZWlnaHQ9IjE1IiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPjwvc3ZnPg==" /> </div> </div> <div class="elementor-element elementor-element-611b9053 other-languages-tech-news elementor-widget elementor-widget-image" data-id="611b9053" data-element_type="widget" data-e-type="widget" data-widget_type="image.default"> <div class="elementor-widget-container"> <img title="techcrunch" alt="techcrunch" nitro-lazy-src="https://cdn-cdahj.nitrocdn.com/UpBIwlpZxVKaCSxNxPFyrgjxpDMdppJI/assets/images/optimized/rev-0576c4c/www.pathsocial.com/wp-content/uploads/2021/10/techcrunch.png" class="nitro-lazy" decoding="async" nitro-lazy-empty id="MTkyNzoxNjM=-1" data-nitro-empty-id="MTkyNzoxNjM=-1" src="data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMTA1IDQ5IiB3aWR0aD0iMTA1IiBoZWlnaHQ9IjQ5IiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPjwvc3ZnPg==" /> </div> </div> </div> </div> </div> </section> </div> </div> <div class="elementor-column elementor-col-33 elementor-top-column elementor-element elementor-element-6e31fff3" data-id="6e31fff3" data-element_type="column" data-e-type="column" data-settings="{&quot;background_background&quot;:&quot;classic&quot;}"> <div class="elementor-widget-wrap elementor-element-populated"> <section class="elementor-section elementor-inner-section elementor-element elementor-element-4d483cd elementor-section-height-min-height elementor-section-boxed elementor-section-height-default" data-id="4d483cd" data-element_type="section" data-e-type="section" id="instagram-growth-below" data-settings="{&quot;background_background&quot;:&quot;classic&quot;}"> <div class="elementor-container elementor-column-gap-default"> <div class="elementor-column elementor-col-100 elementor-inner-column elementor-element elementor-element-1648a505" data-id="1648a505" data-element_type="column" data-e-type="column"> <div class="elementor-widget-wrap elementor-element-populated"> <div class="elementor-element elementor-element-4e90e303 elementor-widget elementor-widget-image" data-id="4e90e303" data-element_type="widget" data-e-type="widget" data-widget_type="image.default"> <div class="elementor-widget-container"> <img width="39" height="40" alt="A quote sign icon." title="quote-img | Path Social | Path Social" nitro-lazy-src="https://cdn-cdahj.nitrocdn.com/UpBIwlpZxVKaCSxNxPFyrgjxpDMdppJI/assets/images/optimized/rev-0576c4c/www.pathsocial.com/wp-content/uploads/2021/10/quote-img.png" class="attachment-full size-full wp-image-14608 nitro-lazy" decoding="async" nitro-lazy-empty id="MTk0MzoyNjk=-1" data-nitro-empty-id="MTk0MzoyNjk=-1" src="data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMzkgNDAiIHdpZHRoPSIzOSIgaGVpZ2h0PSI0MCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48L3N2Zz4=" /> </div> </div> <div class="elementor-element elementor-element-f922d4c pera-box elementor-widget elementor-widget-text-editor" data-id="f922d4c" data-element_type="widget" data-e-type="widget" data-widget_type="text-editor.default"> <div class="elementor-widget-container"> Gaining Instagram followers and an engaged audience has become increasingly difficult and competitive. That’s why we’re keeping an eye on ground-breaking tools like Path Social that help influencers and businesses grow during a tumultuous but explosive era in the social media industry. </div> </div> <div class="elementor-element elementor-element-314ea62d elementor-widget elementor-widget-image" data-id="314ea62d" data-element_type="widget" data-e-type="widget" data-widget_type="image.default"> <div class="elementor-widget-container"> <img width="816" height="15" alt="Underline." sizes="(max-width: 816px) 100vw, 816px" title="border-img | Path Social | Path Social" nitro-lazy-srcset="https://cdn-cdahj.nitrocdn.com/UpBIwlpZxVKaCSxNxPFyrgjxpDMdppJI/assets/images/optimized/rev-0576c4c/www.pathsocial.com/wp-content/uploads/2021/10/border-img.png 816w, https://cdn-cdahj.nitrocdn.com/UpBIwlpZxVKaCSxNxPFyrgjxpDMdppJI/assets/images/optimized/rev-0576c4c/www.pathsocial.com/wp-content/uploads/2021/10/border-img-300x6.png 300w, https://cdn-cdahj.nitrocdn.com/UpBIwlpZxVKaCSxNxPFyrgjxpDMdppJI/assets/images/optimized/rev-0576c4c/www.pathsocial.com/wp-content/uploads/2021/10/border-img-768x14.png 768w" nitro-lazy-src="https://cdn-cdahj.nitrocdn.com/UpBIwlpZxVKaCSxNxPFyrgjxpDMdppJI/assets/images/optimized/rev-0576c4c/www.pathsocial.com/wp-content/uploads/2021/10/border-img.png" class="attachment-full size-full wp-image-14605 nitro-lazy" decoding="async" nitro-lazy-empty id="MTk1MTo1NTA=-1" data-nitro-empty-id="MTk1MTo1NTA=-1" src="data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgODE2IDE1IiB3aWR0aD0iODE2IiBoZWlnaHQ9IjE1IiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPjwvc3ZnPg==" /> </div> </div> <div class="elementor-element elementor-element-99cd6bd other-languages-tech-news elementor-widget elementor-widget-image" data-id="99cd6bd" data-element_type="widget" data-e-type="widget" data-widget_type="image.default"> <div class="elementor-widget-container"> <img width="85" height="40" alt="Business insider logo." title="business_insider | Path Social | Path Social" nitro-lazy-src="https://cdn-cdahj.nitrocdn.com/UpBIwlpZxVKaCSxNxPFyrgjxpDMdppJI/assets/images/optimized/rev-0576c4c/www.pathsocial.com/wp-content/uploads/2021/10/business_insider.png" class="attachment-full size-full wp-image-14606 nitro-lazy" decoding="async" nitro-lazy-empty id="MTk1NToyODc=-1" data-nitro-empty-id="MTk1NToyODc=-1" src="data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgODUgNDAiIHdpZHRoPSI4NSIgaGVpZ2h0PSI0MCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48L3N2Zz4=" /> </div> </div> </div> </div> </div> </section> </div> </div> </div> </section>"};
window.dispatchEvent(new CustomEvent('nitrofragmentloaded', {detail: "f39aaa2f8981b16c9bd5534ac63035a6"}));