[email protected]
(972) 265-9121
CONTACTService Time – SUN 10:30AM
Get In Touch
We love to hear from you.

Your Name (required)

Your Email (required)

Subject

Your Message

WORSHIP ADDRESS

2200 Los Rios Blvd., Plano, TX 75074

MAILING ADDRESS

120 E. FM 544 Ste 72-256, Murphy, TX 75094

OUR EMAIL

[email protected]

CALL US

972-265-9121


                <div class='gf_browser_unknown gform_wrapper' id='gform_wrapper_7' ><div id='gf_7' class='gform_anchor' tabindex='-1'></div><form method='post' enctype='multipart/form-data' target='gform_ajax_frame_7' id='gform_7'  action='/contact/#gf_7'>
                        <div class='gform_body'><ul id='gform_fields_7' class='gform_fields top_label form_sublabel_below description_below'><li id='field_7_1'  class='gfield gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label gfield_label_before_complex'  >Name<span class='gfield_required'>*</span></label><div class='ginput_complex ginput_container no_prefix has_first_name no_middle_name has_last_name no_suffix gf_name_has_2 ginput_container_name' id='input_7_1'>
                            
                            <span id='input_7_1_3_container' class='name_first' >
                                                    <input type='text' name='input_1.3' id='input_7_1_3' value='' aria-label='First name' tabindex='50'  aria-required="true" aria-invalid="false" />
                                                    <label for='input_7_1_3' >First</label>
                                                </span>
                            
                            <span id='input_7_1_6_container' class='name_last' >
                                                    <input type='text' name='input_1.6' id='input_7_1_6' value='' aria-label='Last name' tabindex='52'  aria-required="true" aria-invalid="false" />
                                                    <label for='input_7_1_6' >Last</label>
                                                </span>
                            
                        </div></li><li id='field_7_5'  class='gfield gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_7_5' >Email<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_email'>
                            <input name='input_5' id='input_7_5' type='text' value='' class='medium' tabindex='54'   aria-required="true" aria-invalid="false" />
                        </div></li><li id='field_7_10'  class='gfield gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_7_10' >Phone<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_phone'><input name='input_10' id='input_7_10' type='text' value='' class='medium' tabindex='55'  aria-required="true" aria-invalid="false"  /></div></li><li id='field_7_2'  class='gfield gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label'  >Relationship Status<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_radio'><ul class='gfield_radio' id='input_7_2'><li class='gchoice_7_2_0'><input name='input_2' type='radio' value='Single'  id='choice_7_2_0' tabindex='56'   /><label for='choice_7_2_0' id='label_7_2_0'>Single</label></li><li class='gchoice_7_2_1'><input name='input_2' type='radio' value='Married'  id='choice_7_2_1' tabindex='57'   /><label for='choice_7_2_1' id='label_7_2_1'>Married</label></li><li class='gchoice_7_2_2'><input name='input_2' type='radio' value='Engaged'  id='choice_7_2_2' tabindex='58'   /><label for='choice_7_2_2' id='label_7_2_2'>Engaged</label></li><li class='gchoice_7_2_3'><input name='input_2' type='radio' value='In a Relationship'  id='choice_7_2_3' tabindex='59'   /><label for='choice_7_2_3' id='label_7_2_3'>In a Relationship</label></li><li class='gchoice_7_2_4'><input name='input_2' type='radio' value='Divorced'  id='choice_7_2_4' tabindex='60'   /><label for='choice_7_2_4' id='label_7_2_4'>Divorced</label></li><li class='gchoice_7_2_5'><input name='input_2' type='radio' value='Widowed'  id='choice_7_2_5' tabindex='61'   /><label for='choice_7_2_5' id='label_7_2_5'>Widowed</label></li></ul></div></li><li id='field_7_4'  class='gfield gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_7_4' >How Many Kids<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_select'><select name='input_4' id='input_7_4' class='medium gfield_select' tabindex='62'  aria-required="true" aria-invalid="false"><option value='0' >0</option><option value='1' >1</option><option value='2' >2</option><option value='3 or more.' >3 or more.</option></select></div></li><li id='field_7_6'  class='gfield field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_7_6' >Happily Serving at Connect Church:</label><div class='ginput_container ginput_container_select'><select name='input_6' id='input_7_6' class='medium gfield_select' tabindex='63'   aria-invalid="false"><option value='Yes' >Yes</option><option value='No' >No</option></select></div></li><li id='field_7_7'  class='gfield field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_7_7' >Interested in Learning more about Connect Church:</label><div class='ginput_container ginput_container_select'><select name='input_7' id='input_7_7' class='medium gfield_select' tabindex='64'   aria-invalid="false"><option value='Yes' >Yes</option><option value='No' >No</option></select></div></li><li id='field_7_8'  class='gfield field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_7_8' >Made a decision to recommit to Christ:</label><div class='ginput_container ginput_container_select'><select name='input_8' id='input_7_8' class='medium gfield_select' tabindex='65'   aria-invalid="false"><option value='Yes' >Yes</option><option value='No' >No</option></select></div></li><li id='field_7_9'  class='gfield field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_7_9' >Interested in Baptism:</label><div class='ginput_container ginput_container_select'><select name='input_9' id='input_7_9' class='medium gfield_select' tabindex='66'   aria-invalid="false"><option value='Yes' >Yes</option><option value='No' >No</option></select></div></li>
                            </ul></div>
        <div class='gform_footer top_label'> <input type='submit' id='gform_submit_button_7' class='gform_button button' value='Submit' tabindex='67' onclick='if(window["gf_submitting_7"]){return false;}  window["gf_submitting_7"]=true;  ' onkeypress='if( event.keyCode == 13 ){ if(window["gf_submitting_7"]){return false;} window["gf_submitting_7"]=true;  jQuery("#gform_7").trigger("submit",[true]); }' /> <input type='hidden' name='gform_ajax' value='form_id=7&amp;title=&amp;description=&amp;tabindex=49' />
            <input type='hidden' class='gform_hidden' name='is_submit_7' value='1' />
            <input type='hidden' class='gform_hidden' name='gform_submit' value='7' />
            
            <input type='hidden' class='gform_hidden' name='gform_unique_id' value='' />
            <input type='hidden' class='gform_hidden' name='state_7' value='WyJbXSIsIjEwOTNhZmQwYjdjNTFlNTdmNjFiNTVmNGUwN2MyNTRmIl0=' />
            <input type='hidden' class='gform_hidden' name='gform_target_page_number_7' id='gform_target_page_number_7' value='0' />
            <input type='hidden' class='gform_hidden' name='gform_source_page_number_7' id='gform_source_page_number_7' value='1' />
            <input type='hidden' name='gform_field_values' value='' />
            
        </div>
                        </form>
                        </div>
                <iframe style='display:none;width:0px;height:0px;' src='about:blank' name='gform_ajax_frame_7' id='gform_ajax_frame_7'>This iframe contains the logic required to handle Ajax powered Gravity Forms.</iframe>
                <script type='text/javascript'>jQuery(document).ready(function($){gformInitSpinner( 7, 'https://www.connectchurchplano.com/wp-content/plugins/gravityforms/images/spinner.gif' );jQuery('#gform_ajax_frame_7').on('load',function(){var contents = jQuery(this).contents().find('*').html();var is_postback = contents.indexOf('GF_AJAX_POSTBACK') >= 0;if(!is_postback){return;}var form_content = jQuery(this).contents().find('#gform_wrapper_7');var is_confirmation = jQuery(this).contents().find('#gform_confirmation_wrapper_7').length > 0;var is_redirect = contents.indexOf('gformRedirect(){') >= 0;var is_form = form_content.length > 0 && ! is_redirect && ! is_confirmation;var mt = parseInt(jQuery('html').css('margin-top'), 10) + parseInt(jQuery('body').css('margin-top'), 10) + 100;if(is_form){jQuery('#gform_wrapper_7').html(form_content.html());if(form_content.hasClass('gform_validation_error')){jQuery('#gform_wrapper_7').addClass('gform_validation_error');} else {jQuery('#gform_wrapper_7').removeClass('gform_validation_error');}setTimeout( function() { /* delay the scroll by 50 milliseconds to fix a bug in chrome */ jQuery(document).scrollTop(jQuery('#gform_wrapper_7').offset().top - mt); }, 50 );if(window['gformInitDatepicker']) {gformInitDatepicker();}if(window['gformInitPriceFields']) {gformInitPriceFields();}var current_page = jQuery('#gform_source_page_number_7').val();gformInitSpinner( 7, 'https://www.connectchurchplano.com/wp-content/plugins/gravityforms/images/spinner.gif' );jQuery(document).trigger('gform_page_loaded', [7, current_page]);window['gf_submitting_7'] = false;}else if(!is_redirect){var confirmation_content = jQuery(this).contents().find('.GF_AJAX_POSTBACK').html();if(!confirmation_content){confirmation_content = contents;}setTimeout(function(){jQuery('#gform_wrapper_7').replaceWith(confirmation_content);jQuery(document).scrollTop(jQuery('#gf_7').offset().top - mt);jQuery(document).trigger('gform_confirmation_loaded', [7]);window['gf_submitting_7'] = false;}, 50);}else{jQuery('#gform_7').append(contents);if(window['gformRedirect']) {gformRedirect();}}jQuery(document).trigger('gform_post_render', [7, current_page]);} );} );</script><script type='text/javascript'> jQuery(document).bind('gform_post_render', function(event, formId, currentPage){if(formId == 7) {jQuery('#input_7_10').mask('(999) 999-9999').bind('keypress', function(e){if(e.which == 13){jQuery(this).blur();} } );} } );jQuery(document).bind('gform_post_conditional_logic', function(event, formId, fields, isInit){} );</script><script type='text/javascript'> jQuery(document).ready(function(){jQuery(document).trigger('gform_post_render', [7, 1]) } ); </script>

                <div class='gf_browser_unknown gform_wrapper' id='gform_wrapper_7' ><div id='gf_7' class='gform_anchor' tabindex='-1'></div><form method='post' enctype='multipart/form-data' target='gform_ajax_frame_7' id='gform_7'  action='/contact/#gf_7'>
                        <div class='gform_heading'>
                            <h3 class='gform_title'>Connect Card</h3>
                        </div>
                        <div class='gform_body'><ul id='gform_fields_7' class='gform_fields top_label form_sublabel_below description_below'><li id='field_7_1'  class='gfield gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label gfield_label_before_complex'  >Name<span class='gfield_required'>*</span></label><div class='ginput_complex ginput_container no_prefix has_first_name no_middle_name has_last_name no_suffix gf_name_has_2 ginput_container_name' id='input_7_1'>
                            
                            <span id='input_7_1_3_container' class='name_first' >
                                                    <input type='text' name='input_1.3' id='input_7_1_3' value='' aria-label='First name' tabindex='41'  aria-required="true" aria-invalid="false" />
                                                    <label for='input_7_1_3' >First</label>
                                                </span>
                            
                            <span id='input_7_1_6_container' class='name_last' >
                                                    <input type='text' name='input_1.6' id='input_7_1_6' value='' aria-label='Last name' tabindex='43'  aria-required="true" aria-invalid="false" />
                                                    <label for='input_7_1_6' >Last</label>
                                                </span>
                            
                        </div></li><li id='field_7_5'  class='gfield gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_7_5' >Email<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_email'>
                            <input name='input_5' id='input_7_5' type='text' value='' class='medium' tabindex='45'   aria-required="true" aria-invalid="false" />
                        </div></li><li id='field_7_10'  class='gfield gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_7_10' >Phone<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_phone'><input name='input_10' id='input_7_10' type='text' value='' class='medium' tabindex='46'  aria-required="true" aria-invalid="false"  /></div></li><li id='field_7_2'  class='gfield gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label'  >Relationship Status<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_radio'><ul class='gfield_radio' id='input_7_2'><li class='gchoice_7_2_0'><input name='input_2' type='radio' value='Single'  id='choice_7_2_0' tabindex='47'   /><label for='choice_7_2_0' id='label_7_2_0'>Single</label></li><li class='gchoice_7_2_1'><input name='input_2' type='radio' value='Married'  id='choice_7_2_1' tabindex='48'   /><label for='choice_7_2_1' id='label_7_2_1'>Married</label></li><li class='gchoice_7_2_2'><input name='input_2' type='radio' value='Engaged'  id='choice_7_2_2' tabindex='49'   /><label for='choice_7_2_2' id='label_7_2_2'>Engaged</label></li><li class='gchoice_7_2_3'><input name='input_2' type='radio' value='In a Relationship'  id='choice_7_2_3' tabindex='50'   /><label for='choice_7_2_3' id='label_7_2_3'>In a Relationship</label></li><li class='gchoice_7_2_4'><input name='input_2' type='radio' value='Divorced'  id='choice_7_2_4' tabindex='51'   /><label for='choice_7_2_4' id='label_7_2_4'>Divorced</label></li><li class='gchoice_7_2_5'><input name='input_2' type='radio' value='Widowed'  id='choice_7_2_5' tabindex='52'   /><label for='choice_7_2_5' id='label_7_2_5'>Widowed</label></li></ul></div></li><li id='field_7_4'  class='gfield gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_7_4' >How Many Kids<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_select'><select name='input_4' id='input_7_4' class='medium gfield_select' tabindex='53'  aria-required="true" aria-invalid="false"><option value='0' >0</option><option value='1' >1</option><option value='2' >2</option><option value='3 or more.' >3 or more.</option></select></div></li><li id='field_7_6'  class='gfield field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_7_6' >Happily Serving at Connect Church:</label><div class='ginput_container ginput_container_select'><select name='input_6' id='input_7_6' class='medium gfield_select' tabindex='54'   aria-invalid="false"><option value='Yes' >Yes</option><option value='No' >No</option></select></div></li><li id='field_7_7'  class='gfield field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_7_7' >Interested in Learning more about Connect Church:</label><div class='ginput_container ginput_container_select'><select name='input_7' id='input_7_7' class='medium gfield_select' tabindex='55'   aria-invalid="false"><option value='Yes' >Yes</option><option value='No' >No</option></select></div></li><li id='field_7_8'  class='gfield field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_7_8' >Made a decision to recommit to Christ:</label><div class='ginput_container ginput_container_select'><select name='input_8' id='input_7_8' class='medium gfield_select' tabindex='56'   aria-invalid="false"><option value='Yes' >Yes</option><option value='No' >No</option></select></div></li><li id='field_7_9'  class='gfield field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_7_9' >Interested in Baptism:</label><div class='ginput_container ginput_container_select'><select name='input_9' id='input_7_9' class='medium gfield_select' tabindex='57'   aria-invalid="false"><option value='Yes' >Yes</option><option value='No' >No</option></select></div></li>
                            </ul></div>
        <div class='gform_footer top_label'> <input type='submit' id='gform_submit_button_7' class='gform_button button' value='Submit' tabindex='58' onclick='if(window["gf_submitting_7"]){return false;}  window["gf_submitting_7"]=true;  ' onkeypress='if( event.keyCode == 13 ){ if(window["gf_submitting_7"]){return false;} window["gf_submitting_7"]=true;  jQuery("#gform_7").trigger("submit",[true]); }' /> <input type='hidden' name='gform_ajax' value='form_id=7&amp;title=1&amp;description=&amp;tabindex=40' />
            <input type='hidden' class='gform_hidden' name='is_submit_7' value='1' />
            <input type='hidden' class='gform_hidden' name='gform_submit' value='7' />
            
            <input type='hidden' class='gform_hidden' name='gform_unique_id' value='' />
            <input type='hidden' class='gform_hidden' name='state_7' value='WyJbXSIsIjEwOTNhZmQwYjdjNTFlNTdmNjFiNTVmNGUwN2MyNTRmIl0=' />
            <input type='hidden' class='gform_hidden' name='gform_target_page_number_7' id='gform_target_page_number_7' value='0' />
            <input type='hidden' class='gform_hidden' name='gform_source_page_number_7' id='gform_source_page_number_7' value='1' />
            <input type='hidden' name='gform_field_values' value='' />
            
        </div>
                        </form>
                        </div>
                <iframe style='display:none;width:0px;height:0px;' src='about:blank' name='gform_ajax_frame_7' id='gform_ajax_frame_7'>This iframe contains the logic required to handle Ajax powered Gravity Forms.</iframe>
                <script type='text/javascript'>jQuery(document).ready(function($){gformInitSpinner( 7, 'https://www.connectchurchplano.com/wp-content/plugins/gravityforms/images/spinner.gif' );jQuery('#gform_ajax_frame_7').on('load',function(){var contents = jQuery(this).contents().find('*').html();var is_postback = contents.indexOf('GF_AJAX_POSTBACK') >= 0;if(!is_postback){return;}var form_content = jQuery(this).contents().find('#gform_wrapper_7');var is_confirmation = jQuery(this).contents().find('#gform_confirmation_wrapper_7').length > 0;var is_redirect = contents.indexOf('gformRedirect(){') >= 0;var is_form = form_content.length > 0 && ! is_redirect && ! is_confirmation;var mt = parseInt(jQuery('html').css('margin-top'), 10) + parseInt(jQuery('body').css('margin-top'), 10) + 100;if(is_form){jQuery('#gform_wrapper_7').html(form_content.html());if(form_content.hasClass('gform_validation_error')){jQuery('#gform_wrapper_7').addClass('gform_validation_error');} else {jQuery('#gform_wrapper_7').removeClass('gform_validation_error');}setTimeout( function() { /* delay the scroll by 50 milliseconds to fix a bug in chrome */ jQuery(document).scrollTop(jQuery('#gform_wrapper_7').offset().top - mt); }, 50 );if(window['gformInitDatepicker']) {gformInitDatepicker();}if(window['gformInitPriceFields']) {gformInitPriceFields();}var current_page = jQuery('#gform_source_page_number_7').val();gformInitSpinner( 7, 'https://www.connectchurchplano.com/wp-content/plugins/gravityforms/images/spinner.gif' );jQuery(document).trigger('gform_page_loaded', [7, current_page]);window['gf_submitting_7'] = false;}else if(!is_redirect){var confirmation_content = jQuery(this).contents().find('.GF_AJAX_POSTBACK').html();if(!confirmation_content){confirmation_content = contents;}setTimeout(function(){jQuery('#gform_wrapper_7').replaceWith(confirmation_content);jQuery(document).scrollTop(jQuery('#gf_7').offset().top - mt);jQuery(document).trigger('gform_confirmation_loaded', [7]);window['gf_submitting_7'] = false;}, 50);}else{jQuery('#gform_7').append(contents);if(window['gformRedirect']) {gformRedirect();}}jQuery(document).trigger('gform_post_render', [7, current_page]);} );} );</script><script type='text/javascript'> jQuery(document).bind('gform_post_render', function(event, formId, currentPage){if(formId == 7) {jQuery('#input_7_10').mask('(999) 999-9999').bind('keypress', function(e){if(e.which == 13){jQuery(this).blur();} } );} } );jQuery(document).bind('gform_post_conditional_logic', function(event, formId, fields, isInit){} );</script><script type='text/javascript'> jQuery(document).ready(function(){jQuery(document).trigger('gform_post_render', [7, 1]) } ); </script>