Northwest Regional Map
Find a MARVAC Member Near You!
The map displays all MARVAC members – RV Campgrounds, Dealerships, and Service Providers – in each region. You can learn more about each member by clicking on their icon on the map or locating their listing using the search function. If you’re looking for something specific, like where to get away for a long weekend, select the “Campground” category to see only Campground members; the same applies if you’re looking for RV Dealers or Suppliers.
Once you’ve navigated to a member’s page, you can search nearby attractions, such as local hiking trails or breweries, by using the “Search the Map” function on the right side.
And as RVers, we know that the journey is the half the fun! So be sure to check out one of our regional driving tours, listed below and located in the News section, before you hit the road!
{"map_options":{"center_lat":"44.465243","center_lng":"-85.5","zoom":7,"map_type_id":"ROADMAP","center_by_nearest":false,"fit_bounds":false,"center_circle_fillcolor":"#8CAEF2","center_circle_fillopacity":".5","center_circle_strokecolor":"#8CAEF2","center_circle_strokeopacity":".5","show_center_circle":false,"show_center_marker":false,"center_marker_icon":"https://www.michiganrvandcampgrounds.org/wp-content/plugins/wp-google-map-gold/assets/images//default_marker.png","center_circle_strokeweight":"1","draggable":true,"scroll_wheel":"false","gesture":"auto","marker_default_icon":"https://www.michiganrvandcampgrounds.org/wp-content/plugins/wp-google-map-gold/assets/images//default_marker.png","infowindow_setting":"<div class=\"fc-main\">\n<div class=\"fc-item-title\">{marker_title} <span class=\"fc-badge info\">{marker_category}</span></div>\n<div class=\"fc-item-featured_image\">{marker_image} </div>\n<p>{marker_message}</p>\n<address><b>Address : </b>{marker_address}</address>\n</div>\n","infowindow_geotags_setting":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"{post_link}\">{post_title}</a></div>\r\n</div>","infowindow_skin":{"name":"default","type":"infowindow","sourcecode":"<div class=\"fc-main\"><div class=\"fc-item-title\">{marker_title} <span class=\"fc-badge info\">{marker_category}</span></div> <div class=\"fc-item-featured_image\">{marker_image} </div>{marker_message}<address><b>Address : </b>{marker_address}</address></div>"},"infowindow_post_skin":{"name":"default","type":"post","sourcecode":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"{post_link}\">{post_title}</a></div>\r\n</div>"},"infowindow_drop_animation":false,"close_infowindow_on_map_click":false,"default_infowindow_open":false,"infowindow_open_event":"click","listing_infowindow_open_event":"click","is_mobile":false,"infowindow_filter_only":false,"infowindow_click_change_zoom":0,"infowindow_click_change_center":false,"full_screen_control":true,"search_control":true,"zoom_control":true,"map_type_control":true,"street_view_control":true,"locateme_control":false,"mobile_specific":false,"zoom_mobile":5,"draggable_mobile":true,"scroll_wheel_mobile":true,"full_screen_control_position":"TOP_RIGHT","search_control_position":"TOP_LEFT","locateme_control_position":"TOP_LEFT","zoom_control_position":"TOP_LEFT","map_type_control_position":"TOP_RIGHT","map_type_control_style":"HORIZONTAL_BAR","street_view_control_position":"TOP_LEFT","map_control":false,"screens":{"smartphones":{"map_zoom_level_mobile":"5"},"ipads":{"map_zoom_level_mobile":"5"},"large-screens":{"map_zoom_level_mobile":"5"}},"map_infowindow_customisations":false,"infowindow_width":"100%","infowindow_border_color":"rgba(0, 0, 0, 0.0980392)","infowindow_bg_color":"#fff","show_infowindow_header":false,"min_zoom":"0","max_zoom":"19","zoom_level_after_search":10,"url_filters":false,"doubleclickzoom":false,"current_post_only":false,"bound_map_after_filter":false,"display_reset_button":false,"map_reset_button_text":"Reset","height":"500"},"places":[{"source":"post","title":"Cherry Capital RV","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/cherry-capital-rv/\">Cherry Capital RV</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Cherry Capital RV is located at Just Trucks just a few miles southwest of Traverse City.  The repair side of the business has enormous experience in their ability to service and repair Class A diesels to small travel trailers. Just Trucks also has full chassis service and commercial truck repair.<br /> 7030 US 31 South Grawn, MI 49637","address":"7030 US 31 South, Grawn, MI 49637","location":{"lat":"44.664452","lng":"-85.7172595","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/cherry-capital-rv/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Cherry Capital RV is located at Just Trucks just a few miles southwest of Traverse City.  The repair side of the business has enormous experience in their ability to service and repair Class A diesels to small travel trailers. Just Trucks also has full chassis service and commercial truck repair.<br /> 7030 US 31 South Grawn, MI 49637","post_content":"[mmi_map]\r\n\r\n<img class=\"alignright wp-image-25447\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2021/02/ccrv.png\" alt=\"\" width=\"180\" /><h1>Cherry Capital RV</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nCherry Capital RV is located at Just Trucks just a few miles southwest of Traverse City.  The repair side of the business has enormous experience in their ability to service and repair Class A diesels to small travel trailers. Just Trucks also has full chassis service and commercial truck repair.\r\n\r\n7030 US 31 South\r\n  Grawn, MI 49637\r\n\r\n<strong>\r\nPhone: 231-276-5158\r\nWebsite: <a href=\"http://www.cherrycapitalrv.com\" target=\"_blank\" rel=\"noopener\">www.cherrycapitalrv.com</a>\r\n </strong>\r\n\r\nServices Roof-Mount Air Conditioning\r\n\r\n\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2021/02/ccrv1_offered-by.png\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2021/02/ccrv2_big-sign.jpg\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2021/02/ccrv3_Just-Trucks-red-doors.png\" />\r\n  ","post_title":"Cherry Capital RV","post_link":"https://www.michiganrvandcampgrounds.org/member-info/cherry-capital-rv/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Cherry Capital RV\" width=\"300\" height=\"211\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2021/02/ccrv1_offered-by-300x211.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"7030 US 31 South, Grawn, MI 49637","errors":[],"address_formatted":"7030 US-31, Grawn, MI 49637, USA","lat":"44.664452","lng":"-85.7172595","street_number":"7030","street_name_long":"U.S. 31","street_name_short":"US-31","city":"Grawn","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49637"},"%_mmi_phone%":"231-276-5158","%_mmi_url%":"www.cherrycapitalrv.com","%_wpgmp_location_address%":"7030 US 31 South, Grawn, MI 49637","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"91\";}","%_wpgmp_metabox_latitude%":"44.664452","%_wpgmp_metabox_longitude%":"-85.7172595","%_wp_old_date%":"2020-06-23","%_fusion%":"","%_edit_lock%":"1613654489:2","%avada_post_views_count%":"2169","%avada_today_post_views_count%":"7","%avada_post_views_count_today_date%":"26-04-2024","%_thumbnail_id%":"73392","taxonomy=portfolio_category":"Dealers, Northwest Michigan Region, Services Roof-Mount Air Conditioning","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/dealer-e1456842808766.png"},"id":72583,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/dealer-e1456842808766.png","name":"Dealers","id":"91","type":"category"}]},{"source":"post","title":"Vacation Trailer Sales","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/vacation-trailer-sales/\">Vacation Trailer Sales</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Open Monday through Saturday. Dealer for Coachmen and Forest River.<br /> 1776 Benzie Highway Benzonia, MI 49616","address":"1776 Benzie Highway, Benzonia, MI 49616","location":{"lat":"44.606663","lng":"-86.0997971","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/vacation-trailer-sales/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Open Monday through Saturday. Dealer for Coachmen and Forest River.<br /> 1776 Benzie Highway Benzonia, MI 49616","post_content":"[mmi_map]\r\n\r\n <h1>Vacation Trailer Sales</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nOpen Monday through Saturday. Dealer for Coachmen and Forest River.\r\n\r\n1776 Benzie Highway\r\n  Benzonia, MI 49616\r\n\r\n<strong>\r\nPhone: (231) 882-0450\r\nFax: (231) 882-9843\r\nWebsite: <a href=\"http://www.vacationtrailer.com\" target=\"_blank\" rel=\"noopener\">www.vacationtrailer.com</a>\r\n </strong>\r\n\r\nServices All RVs\r\nRents RVs\r\nServices Roof-Mount Air Conditioning\r\nRoad Service\r\nStorage\r\nServices Major Appliances\r\nSells Parts &amp; Accessories\r\nSells &amp; Installs Hitches\r\nOnline Reservations\r\n\r\n\r\n     ","post_title":"Vacation Trailer Sales","post_link":"https://www.michiganrvandcampgrounds.org/member-info/vacation-trailer-sales/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Vacation Trailer Sales\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/05/d6-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%c4p_log_redirect_to%":null,"%_mmi_location%":{"geocoded":true,"address_raw":"1776 Benzie Highway, Benzonia, MI 49616","errors":[],"address_formatted":"1776 Benzie Hwy, Benzonia, MI 49616, USA","lat":"44.606663","lng":"-86.0997971","street_number":"1776","street_name_long":"Benzie Highway","street_name_short":"Benzie Hwy","city":"Benzonia","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49616"},"%_mmi_phone%":"(231) 882-0450","%_mmi_url%":"www.vacationtrailer.com","%_wpgmp_location_address%":"1776 Benzie Highway, Benzonia, MI 49616","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"91\";}","%_wpgmp_metabox_latitude%":"44.606663","%_wpgmp_metabox_longitude%":"-86.0997971","%_wp_old_date%":"2018-04-03","%_fusion%":"","%avada_post_views_count%":"2252","%avada_today_post_views_count%":"11","%avada_post_views_count_today_date%":"26-04-2024","%_thumbnail_id%":"29889","taxonomy=portfolio_category":"Dealers, Northwest Michigan Region, Online Reservations \u2013 S, Rents RVs, Road Service, Sells &amp; Installs Hitches, Sells Parts &amp; Accessories, Services All RVs, Services Major Appliances, Services Roof-Mount Air Conditioning, Storage","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/dealer-e1456842808766.png"},"id":41573,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/dealer-e1456842808766.png","name":"Dealers","id":"91","type":"category"}]},{"source":"post","title":"Vacation Trailer Sales &#8211; Manistee","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/vacation-trailer-sales-manistee/\">Vacation Trailer Sales &#8211; Manistee</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Open Monday through Saturday. Dealer for Coachmen and Forest River.<br /> 10991 North US 31 Manistee, MI 49660","address":"10991 North US 31, Manistee, MI 49660","location":{"lat":"44.1537366","lng":"-86.2798573","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/vacation-trailer-sales-manistee/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Open Monday through Saturday. Dealer for Coachmen and Forest River.<br /> 10991 North US 31 Manistee, MI 49660","post_content":"[mmi_map]\r\n\r\n <h1>Vacation Trailer Sales - Manistee</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nOpen Monday through Saturday. Dealer for Coachmen and Forest River.\r\n\r\n10991 North US 31\r\n  Manistee, MI 49660\r\n\r\n<strong>\r\nPhone: (231) 398-0400\r\nFax: (231) 398-9832\r\nWebsite: <a href=\"http://www.vacationtrailer.com\" target=\"_blank\" rel=\"noopener\">www.vacationtrailer.com</a>\r\n </strong>\r\n\r\nServices All RVs\r\nSells Propane Gas\r\nRents RVs\r\nServices Roof-Mount Air Conditioning\r\nRoad Service\r\nStorage\r\nServices Major Appliances\r\nSells Parts &amp; Accessories\r\nSells &amp; Installs Hitches\r\nOnline Reservations\r\n\r\n\r\n     ","post_title":"Vacation Trailer Sales &#8211; Manistee","post_link":"https://www.michiganrvandcampgrounds.org/member-info/vacation-trailer-sales-manistee/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Vacation Trailer Sales &#8211; Manistee\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/05/d5-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%c4p_log_redirect_to%":null,"%_mmi_location%":{"geocoded":true,"address_raw":"10991 North US 31, Manistee, MI 49660","errors":[],"address_formatted":"10991 US-31, Manistee, MI 49660, USA","lat":"44.1537366","lng":"-86.2798573","street_number":"10991","street_name_long":"U.S. 31","street_name_short":"US-31","city":"Manistee","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49660"},"%_mmi_phone%":"(231) 398-0400","%_mmi_url%":"www.vacationtrailer.com","%_wpgmp_location_address%":"10991 North US 31, Manistee, MI 49660","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"91\";}","%_wpgmp_metabox_latitude%":"44.1537366","%_wpgmp_metabox_longitude%":"-86.2798573","%_wp_old_date%":"2018-04-03","%_fusion%":"","%_wp_old_slug%":"vacation-trailer-sales-2","%avada_post_views_count%":"2634","%avada_today_post_views_count%":"14","%avada_post_views_count_today_date%":"26-04-2024","%_thumbnail_id%":"29892","taxonomy=portfolio_category":"Dealers, Northwest Michigan Region, Online Reservations \u2013 S, Propane Gas, Rents RVs, Road Service, Sells &amp; Installs Hitches, Sells Parts &amp; Accessories, Services All RVs, Services Major Appliances, Services Roof-Mount Air Conditioning, Storage","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/dealer-e1456842808766.png"},"id":41584,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/dealer-e1456842808766.png","name":"Dealers","id":"91","type":"category"}]},{"source":"post","title":"Team One Trailers, LLC","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/team-one-trailers-llc/\">Team One Trailers, LLC</a></div>\r\n</div>","content":"Northwest Michigan Region<br /><br /> 981 W. Blue Star Dr. Traverse City, MI 49685","address":"981 W. Blue Star Dr., Traverse City, MI 49685","location":{"lat":"44.6987242","lng":"-85.6550188","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/team-one-trailers-llc/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br /><br /> 981 W. Blue Star Dr. Traverse City, MI 49685","post_content":"[mmi_map]\r\n\r\n <h1>Team One Trailers, LLC</h1>\r\n<h2>Northwest Michigan Region</h2>\r\n\r\n\r\n981 W. Blue Star Dr.\r\n  Traverse City, MI 49685\r\n\r\n<strong>\r\nPhone: (231) 943-1220\r\nFax: (231) 943-1221\r\nWebsite: <a href=\"http://www.teamonetrailers.com\" target=\"_blank\" rel=\"noopener\">www.teamonetrailers.com</a>\r\n </strong>\r\n\r\nServices Only What We Sell\r\nServices Roof-Mount Air Conditioning\r\nSells Parts &amp; Accessories\r\nSells &amp; Installs Hitches\r\n\r\n\r\n     ","post_title":"Team One Trailers, LLC","post_link":"https://www.michiganrvandcampgrounds.org/member-info/team-one-trailers-llc/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Team One Trailers, LLC\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2023/11/d9-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%c4p_log_redirect_to%":null,"%_mmi_location%":{"geocoded":true,"address_raw":"981 W. Blue Star Dr., Traverse City, MI 49685","errors":[],"address_formatted":"981 W Blue Star Dr, Traverse City, MI 49685, USA","lat":"44.6987242","lng":"-85.6550188","street_number":"981","street_name_long":"West Blue Star Drive","street_name_short":"W Blue Star Dr","city":"Traverse City","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49685"},"%_mmi_phone%":"(231) 943-1220","%_mmi_url%":"www.teamonetrailers.com","%_wpgmp_location_address%":"981 W. Blue Star Dr., Traverse City, MI 49685","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"91\";}","%_wpgmp_metabox_latitude%":"44.6987242","%_wpgmp_metabox_longitude%":"-85.6550188","%_wp_old_date%":"2018-04-03","%_edit_lock%":"1580483676:11","%_fusion%":"","%avada_post_views_count%":"2308","%avada_today_post_views_count%":"9","%avada_post_views_count_today_date%":"26-04-2024","%_thumbnail_id%":"75652","taxonomy=portfolio_category":"Dealers, Northwest Michigan Region, Sells &amp; Installs Hitches, Sells Parts &amp; Accessories, Services Only What We Sell, Services Roof-Mount Air Conditioning","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/dealer-e1456842808766.png"},"id":41592,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/dealer-e1456842808766.png","name":"Dealers","id":"91","type":"category"}]},{"source":"post","title":"Bish&#8217;s RV of Ludington","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/bishs-rv-of-ludington/\">Bish&#8217;s RV of Ludington</a></div>\r\n</div>","content":"Northwest Michigan Region<br />One block east of US-31 at US-10 and Dennis Road. We carry Cedar Creek, Salem, Sierra, Flagstaff, White Water, Vengeance and North Trail, with full parts and service. Mobile service with two vans also available.<br /> 66 N. Dennis Road Ludington, MI 49431","address":"66 N. Dennis Road, Ludington, MI 49431","location":{"lat":"43.957355","lng":"-86.368915","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/bishs-rv-of-ludington/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />One block east of US-31 at US-10 and Dennis Road. We carry Cedar Creek, Salem, Sierra, Flagstaff, White Water, Vengeance and North Trail, with full parts and service. Mobile service with two vans also available.<br /> 66 N. Dennis Road Ludington, MI 49431","post_content":"[mmi_map]\r\n\r\n <h1>Bish's RV of Ludington</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nOne block east of US-31 at US-10 and Dennis Road. We carry Cedar Creek, Salem, Sierra, Flagstaff, White Water, Vengeance and North Trail, with full parts and service. Mobile service with two vans also available.\r\n\r\n66 N. Dennis Road\r\n  Ludington, MI 49431\r\n\r\n<strong>\r\nPhone: (231) 845-8282\r\nFax: (231) 845-8787\r\nWebsite: <a href=\"http://www.bishs.com\" target=\"_blank\" rel=\"noopener\">www.bishs.com</a>\r\n </strong>\r\n\r\nServices All RVs\r\nServices Roof-Mount Air Conditioning\r\nServices Major Appliances\r\nSells Parts &amp; Accessories\r\nSells &amp; Installs Hitches\r\n\r\n\r\n     ","post_title":"Bish&#8217;s RV of Ludington","post_link":"https://www.michiganrvandcampgrounds.org/member-info/bishs-rv-of-ludington/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Bish&#8217;s RV of Ludington\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/05/d3-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%c4p_log_redirect_to%":null,"%_mmi_location%":{"geocoded":true,"address_raw":"66 N. Dennis Road, Ludington, MI 49431","errors":[],"address_formatted":"66 N Dennis Rd, Ludington, MI 49431, USA","lat":"43.957355","lng":"-86.368915","street_number":"66","street_name_long":"North Dennis Road","street_name_short":"N Dennis Rd","city":"Ludington","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49431"},"%_mmi_phone%":"(231) 845-8282","%_mmi_url%":"www.bishs.com","%_wpgmp_location_address%":"66 N. Dennis Road, Ludington, MI 49431","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"91\";}","%_wpgmp_metabox_latitude%":"43.957355","%_wpgmp_metabox_longitude%":"-86.368915","%_wp_old_date%":"2019-03-09","%_fusion%":"","%_wp_old_slug%":"fun-n-sun-rv-center-of-ludington","%avada_post_views_count%":"3246","%avada_today_post_views_count%":"15","%avada_post_views_count_today_date%":"26-04-2024","%_thumbnail_id%":"29890","taxonomy=portfolio_category":"Dealers, Northwest Michigan Region, Sells &amp; Installs Hitches, Sells Parts &amp; Accessories, Services All RVs, Services Major Appliances, Services Roof-Mount Air Conditioning","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/dealer-e1456842808766.png"},"id":67806,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/dealer-e1456842808766.png","name":"Dealers","id":"91","type":"category"}]},{"source":"post","title":"Nature &#038; Me RV LLC","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/nature-me-rv-llc/\">Nature &#038; Me RV LLC</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Nature and Me RV is a one stop shop for all your RV needs. We carry multiple different lines of travel trailers: Airstream, Lance, Palomino Puma, Forest River Sierra, Keystone Bullet/Premier, Palomino Pause, Palomino Solaire, nuCamp teardrops. We have a full service and parts department. Our hours are M-F 9am - 5pm year round. Saturdays are seasonal March - November 10am - 2 pm.<br /> 3938 Rennie School Road Traverse City, MI 48684","address":"3938 Rennie School Road, Traverse City, MI 48684","location":{"lat":"44.6869351","lng":"-85.6550074","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/nature-me-rv-llc/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Nature and Me RV is a one stop shop for all your RV needs. We carry multiple different lines of travel trailers: Airstream, Lance, Palomino Puma, Forest River Sierra, Keystone Bullet/Premier, Palomino Pause, Palomino Solaire, nuCamp teardrops. We have a full service and parts department. Our hours are M-F 9am - 5pm year round. Saturdays are seasonal March - November 10am - 2 pm.<br /> 3938 Rennie School Road Traverse City, MI 48684","post_content":"[mmi_map]\r\n\r\n <h1>Nature & Me RV LLC</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nNature and Me RV is a one stop shop for all your RV needs. We carry multiple different lines of travel trailers: Airstream, Lance, Palomino Puma, Forest River Sierra, Keystone Bullet/Premier, Palomino Pause, Palomino Solaire, nuCamp teardrops. We have a full service and parts department. Our hours are M-F 9am - 5pm year round. Saturdays are seasonal March - November 10am - 2 pm.\r\n\r\n3938 Rennie School Road\r\n  Traverse City, MI 48684\r\n\r\n<strong>\r\nPhone: (231) 943-5858\r\nFax: (231) 943-0400\r\nWebsite: <a href=\"http://www.natureandmerv.com\" target=\"_blank\" rel=\"noopener\">www.natureandmerv.com</a>\r\n </strong>\r\n\r\nServices Only What We Sell\r\nServices Roof-Mount Air Conditioning\r\nSells Parts &amp; Accessories\r\n\r\n\r\n     ","post_title":"Nature &#038; Me RV LLC","post_link":"https://www.michiganrvandcampgrounds.org/member-info/nature-me-rv-llc/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Nature &#038; Me RV LLC\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2017/11/d4-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"3938 Rennie School Road, Traverse City, MI 48684","errors":[],"address_formatted":"3938 Rennie School Rd, Traverse City, MI 49685, USA","lat":"44.6869351","lng":"-85.6550074","street_number":"3938","street_name_long":"Rennie School Road","street_name_short":"Rennie School Rd","city":"Traverse City","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49685"},"%_mmi_phone%":"(231) 943-5858","%_mmi_url%":"www.natureandmerv.com","%_wpgmp_location_address%":"3938 Rennie School Road, Traverse City, MI 48684","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"91\";}","%_wpgmp_metabox_latitude%":"44.6869351","%_wpgmp_metabox_longitude%":"-85.6550074","%_fusion%":"","%avada_post_views_count%":"1078","%avada_today_post_views_count%":"6","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2023-01-24","%_thumbnail_id%":"51043","taxonomy=portfolio_category":"Dealers, Northwest Michigan Region, Sells Parts &amp; Accessories, Services Only What We Sell, Services Roof-Mount Air Conditioning","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/dealer-e1456842808766.png"},"id":75142,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/dealer-e1456842808766.png","name":"Dealers","id":"91","type":"category"}]},{"source":"post","title":"Bish&#8217;s RV of Traverse City","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/bishs-rv-of-traverse-city/\">Bish&#8217;s RV of Traverse City</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Family owned and operated for 26 years! Consistent customer satisfaction leader. We have 10 service bays and a parts and accessories store. RV damage, appliance repair, dinghy towing. We are the specialists! Proud to be an exclusive Jayco dealer!<br /> 705 N. US 31 South Traverse City, MI 49685","address":"705 N. US 31 South, Traverse City, MI 49685","location":{"lat":"44.6967656","lng":"-85.6562685","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/bishs-rv-of-traverse-city/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Family owned and operated for 26 years! Consistent customer satisfaction leader. We have 10 service bays and a parts and accessories store. RV damage, appliance repair, dinghy towing. We are the specialists! Proud to be an exclusive Jayco dealer!<br /> 705 N. US 31 South Traverse City, MI 49685","post_content":"[mmi_map]\r\n\r\n <h1>Bish's RV of Traverse City</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nFamily owned and operated for 26 years! Consistent customer satisfaction leader. We have 10 service bays and a parts and accessories store. RV damage, appliance repair, dinghy towing. We are the specialists! Proud to be an exclusive Jayco dealer!\r\n\r\n705 N. US 31 South\r\n  Traverse City, MI 49685\r\n\r\n<strong>\r\nPhone: (231) 943-4050\r\nFax: (231) 943-4075\r\nWebsite: <a href=\"http://tcrv.com/\" target=\"_blank\" rel=\"noopener\">http://tcrv.com/</a>\r\n </strong>\r\n\r\nServices All RVs\r\nSells Propane Gas\r\nRents RVs\r\nServices Roof-Mount Air Conditioning\r\nServices Major Appliances\r\nSells Parts &amp; Accessories\r\nSells &amp; Installs Hitches\r\n\r\n\r\n     ","post_title":"Bish&#8217;s RV of Traverse City","post_link":"https://www.michiganrvandcampgrounds.org/member-info/bishs-rv-of-traverse-city/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Bish&#8217;s RV of Traverse City\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/05/d6-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%c4p_log_redirect_to%":null,"%_mmi_location%":{"geocoded":true,"address_raw":"705 N. US 31 South, Traverse City, MI 49685","errors":[],"address_formatted":"705 US-31, Traverse City, MI 49685, USA","lat":"44.6967656","lng":"-85.6562685","street_number":"705","street_name_long":"U.S. 31","street_name_short":"US-31","city":"Traverse City","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49685"},"%_mmi_phone%":"(231) 943-4050","%_mmi_url%":"http://tcrv.com/","%_wpgmp_location_address%":"705 N. US 31 South, Traverse City, MI 49685","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"91\";}","%_wpgmp_metabox_latitude%":"44.6967656","%_wpgmp_metabox_longitude%":"-85.6562685","%_wp_old_date%":"2018-04-03","%_fusion%":"","%avada_post_views_count%":"3262","%avada_today_post_views_count%":"12","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_slug%":"tc-rv-inc","%_thumbnail_id%":"29889","taxonomy=portfolio_category":"Dealers, Northwest Michigan Region, Propane Gas, Rents RVs, Sells &amp; Installs Hitches, Sells Parts &amp; Accessories, Services All RVs, Services Major Appliances, Services Roof-Mount Air Conditioning","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/dealer-e1456842808766.png"},"id":41563,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/dealer-e1456842808766.png","name":"Dealers","id":"91","type":"category"}]},{"source":"post","title":"Magnus Park Campground","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/magnus-park-campground/\">Magnus Park Campground</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Magnus Park Campground provides 76-sites for tents, tow-able recreational vehicles, and motor homes. The campground rests at the end of West Lake Street along the shores of Little Traverse Bay. Campers staying at Magnus Park have easy access to Bayfront Park, Little Traverse Wheelway, Northern Michigan Regional Hospital, and Downtown Petoskey.\n\nMagnus Park provides camping facilities as well as day-use amenities along the shores of Lake Michigan&#x2019;s Little Traverse Bay. The park has 1,000 feet of shoreline and is equipped with access roads, utilities, a wooded area, and scenic views of Little Traverse Bay. A small overlook area, known as &#x201C;Wayside Park,&#x201D; on the upper-elevation bluff adjacent to the bike path also provides excellent views of the bay. Free wireless internet is available throughout the campground.<br /> 101 East Lake Street Petoskey, MI 49770","address":"101 East Lake Street, Petoskey, MI 49770","location":{"lat":"45.3752831","lng":"-84.9603045","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/magnus-park-campground/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Magnus Park Campground provides 76-sites for tents, tow-able recreational vehicles, and motor homes. The campground rests at the end of West Lake Street along the shores of Little Traverse Bay. Campers staying at Magnus Park have easy access to Bayfront Park, Little Traverse Wheelway, Northern Michigan Regional Hospital, and Downtown Petoskey.\n\nMagnus Park provides camping facilities as well as day-use amenities along the shores of Lake Michigan&#x2019;s Little Traverse Bay. The park has 1,000 feet of shoreline and is equipped with access roads, utilities, a wooded area, and scenic views of Little Traverse Bay. A small overlook area, known as &#x201C;Wayside Park,&#x201D; on the upper-elevation bluff adjacent to the bike path also provides excellent views of the bay. Free wireless internet is available throughout the campground.<br /> 101 East Lake Street Petoskey, MI 49770","post_content":"[mmi_map]\r\n\r\n <h1>Magnus Park Campground</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nMagnus Park Campground provides 76-sites for tents, tow-able recreational vehicles, and motor homes. The campground rests at the end of West Lake Street along the shores of Little Traverse Bay. Campers staying at Magnus Park have easy access to Bayfront Park, Little Traverse Wheelway, Northern Michigan Regional Hospital, and Downtown Petoskey.\n\nMagnus Park provides camping facilities as well as day-use amenities along the shores of Lake Michigan&#x2019;s Little Traverse Bay. The park has 1,000 feet of shoreline and is equipped with access roads, utilities, a wooded area, and scenic views of Little Traverse Bay. A small overlook area, known as &#x201C;Wayside Park,&#x201D; on the upper-elevation bluff adjacent to the bike path also provides excellent views of the bay. Free wireless internet is available throughout the campground.\r\n\r\n101 East Lake Street\r\nPetoskey, MI 49770\r\n\r\n<strong>\r\n\r\nPhone: (231) 347-2500\r\n Website: <a href=\"https://www.petoskey.us/services/parks___recreation/campground.php\" target=\"_blank\" rel=\"noopener\">https://www.petoskey.us/services/parks___recreation/campground.php</a>\r\nemail: <a href=\"mailto:magnuspark@petoskey.us\">magnuspark@petoskey.us</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nLaundry Facilities\r\nFishing\r\nWiFi Available\r\nPet Friendly\r\nPull-Through Sites\r\nTent Sites\r\nCabin Rentals\r\nHandicap Accessible\r\nOnline Reservations\r\n\r\n\r\n     ","post_title":"Magnus Park Campground","post_link":"https://www.michiganrvandcampgrounds.org/member-info/magnus-park-campground/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Magnus Park Campground\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2017/05/c6-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"101 East Lake Street, Petoskey, MI 49770","errors":[],"address_formatted":"101 E Lake St, Petoskey, MI 49770, USA","lat":"45.3752831","lng":"-84.9603045","street_number":"101","street_name_long":"East Lake Street","street_name_short":"E Lake St","city":"Petoskey","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49770"},"%_mmi_phone%":"(231) 347-2500","%_mmi_url%":"https://www.petoskey.us/services/parks___recreation/campground.php","%_wpgmp_location_address%":"101 East Lake Street, Petoskey, MI 49770","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_wpgmp_metabox_latitude%":"45.3752831","%_wpgmp_metabox_longitude%":"-84.9603045","%_fusion%":{"fimg":{"width":"","height":""},"bg_full":"no","display_header":"yes","header_bg_full":"no","slider_visibility":"small-visibility,medium-visibility,large-visibility","main_padding":{"top":"","bottom":""},"content_bg_full":"no","image_rollover_icons":"default","bg_repeat":"default","header_bg_repeat":"repeat","displayed_menu":"default","slider_type":"no","slider":"0","wooslider":"0","elasticslider":"0","page_title_bar":"default","content_bg_repeat":"default"},"%_wp_old_date%":"2023-01-20","%avada_post_views_count%":"2184","%avada_today_post_views_count%":"3","%avada_post_views_count_today_date%":"26-04-2024","%_edit_lock%":"1684954847:20","%_edit_last%":"20","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_custom_link%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_fusion_google_fonts%":"","%fusion_builder_status%":"","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_thumbnail_id%":"46155","taxonomy=portfolio_category":"Cabin Rentals, Campgrounds, Fishing, Full Hook-Up, Handicap Accessible, Laundry Facilities, Northwest Michigan Region, Online Reservations, Pet Friendly, Pull-Through Sites, Swimming, Tent Sites, WiFi Available","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":75138,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Big Prairie Township Parks","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/big-prairie-township-parks/\">Big Prairie Township Parks</a></div>\r\n</div>","content":"Northwest Michigan Region<br />The Big Prairie Township Parks are located in the backwater of Hardy Dam, the third largest earthen dam in the United States!  There are 17 miles of waterway from Hardy Dam to Rogers Dam for recreational waterskiing, swimming, fishing or boating.<br /> 2973 Cottonwood Ave. Newaygo, MI 49337","address":"2973 Cottonwood Ave., Newaygo, MI 49337","location":{"lat":"43.5041821","lng":"-85.6089253","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/big-prairie-township-parks/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />The Big Prairie Township Parks are located in the backwater of Hardy Dam, the third largest earthen dam in the United States!  There are 17 miles of waterway from Hardy Dam to Rogers Dam for recreational waterskiing, swimming, fishing or boating.<br /> 2973 Cottonwood Ave. Newaygo, MI 49337","post_content":"[mmi_map]\r\n\r\n <h1>Big Prairie Township Parks</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nThe Big Prairie Township Parks are located in the backwater of Hardy Dam, the third largest earthen dam in the United States!  There are 17 miles of waterway from Hardy Dam to Rogers Dam for recreational waterskiing, swimming, fishing or boating.\r\n\r\n2973 Cottonwood Ave.\r\nNewaygo, MI 49337\r\n\r\n<strong>\r\n\r\nPhone: (231) 856-4279\r\nFax: (231) 856-0005\r\nWebsite: <a href=\"http://www.newaygoparks.com/\" target=\"_blank\" rel=\"noopener\">www.newaygoparks.com/</a>\r\nemail: <a href=\"mailto:oxbowpark@hotmail.com\">oxbowpark@hotmail.com</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nSwimming\r\nFishing\r\nRecreation Facilities\r\nPlanned Activities\r\nCamp Store\r\nWiFi Available\r\nPet Friendly\r\nBoat Canoe Rentals\r\nPull-Through Sites\r\nTent Sites\r\nYear-Round Camping\r\nCabin Rentals\r\nHandicap Accessible\r\nOnline Reservations\r\nCall For Information\r\n\r\n\r\n     ","post_title":"Big Prairie Township Parks","post_link":"https://www.michiganrvandcampgrounds.org/member-info/big-prairie-township-parks/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Big Prairie Township Parks\" width=\"300\" height=\"201\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2022/01/c17-300x201.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"2973 Cottonwood Ave., Newaygo, MI 49337","errors":[],"address_formatted":"2973 Cottonwood Ave, Newaygo, MI 49337, USA","lat":"43.5041821","lng":"-85.6089253","street_number":"2973","street_name_long":"Cottonwood Avenue","street_name_short":"Cottonwood Ave","city":"Newaygo","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49337"},"%_mmi_phone%":"(231) 856-4279","%_mmi_url%":"www.newaygoparks.com/","%_wpgmp_location_address%":"2973 Cottonwood Ave., Newaygo, MI 49337","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_wpgmp_metabox_latitude%":"43.5041821","%_wpgmp_metabox_longitude%":"-85.6089253","%_fusion%":"","%avada_post_views_count%":"739","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2023-02-17","%_edit_lock%":"1684781798:20","%_thumbnail_id%":"74298","taxonomy=portfolio_category":"Boat Canoe Rentals, Cabin Rentals, Camp Store, Campgrounds, Fishing, Handicap Accessible, Northwest Michigan Region, Online Reservations, Pet Friendly, Planned Activities, Pull-Through Sites, Recreation Facilities, Swimming, Tent Sites, WiFi Available, Year-Round Camping","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":75211,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Woodland Shores RV Resort","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/woodland-shores-rv-resort/\">Woodland Shores RV Resort</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Beach on Lake Michigan, lots of walking/hiking trails, pool, hot tub, palyground, rv rentals, cabins, campsites, Large mature sites, events and activities, arcade, dog park.<br /> 4370 Ridge Road Mears, MI 49436","address":"4370 Ridge Road, Mears, MI 49436","location":{"lat":"43.7272968","lng":"-86.4760691","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/woodland-shores-rv-resort/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Beach on Lake Michigan, lots of walking/hiking trails, pool, hot tub, palyground, rv rentals, cabins, campsites, Large mature sites, events and activities, arcade, dog park.<br /> 4370 Ridge Road Mears, MI 49436","post_content":"[mmi_map]\r\n\r\n <h1>Woodland Shores RV Resort</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nBeach on Lake Michigan, lots of walking/hiking trails, pool, hot tub, palyground, rv rentals, cabins, campsites, Large mature sites, events and activities, arcade, dog park.\r\n\r\n4370 Ridge Road\r\nMears, MI 49436\r\n\r\n<strong>\r\n\r\nPhone: 231-742-7045\r\n Website: <a href=\"http://www.thewoodlandshores.com\" target=\"_blank\" rel=\"noopener\">www.thewoodlandshores.com</a>\r\nemail: <a href=\"mailto:customerservice@thewoodlandshores.com\">customerservice@thewoodlandshores.com</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nSwimming\r\nLaundry Facilities\r\nPlanned Activities\r\nCamp Store\r\nPet Friendly\r\nSells Propane Gas\r\nPull-Through Sites\r\nTent Sites\r\nCabin Rentals\r\nOnline Reservations\r\n\r\n\r\n     ","post_title":"Woodland Shores RV Resort","post_link":"https://www.michiganrvandcampgrounds.org/member-info/woodland-shores-rv-resort/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Woodland Shores RV Resort\" width=\"300\" height=\"201\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2022/01/c17-300x201.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"4370 Ridge Road, Mears, MI 49436","errors":[],"address_formatted":"4370 N Ridge Rd, Mears, MI 49436, USA","lat":"43.7272968","lng":"-86.4760691","street_number":"4370","street_name_long":"North Ridge Road","street_name_short":"N Ridge Rd","city":"Mears","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49436"},"%_mmi_phone%":"231-742-7045","%_mmi_url%":"www.thewoodlandshores.com","%_wpgmp_location_address%":"4370 Ridge Road, Mears, MI 49436","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_wpgmp_metabox_latitude%":"43.7272968","%_wpgmp_metabox_longitude%":"-86.4760691","%_fusion%":{"fimg":{"width":"","height":""},"bg_full":"no","display_header":"yes","header_bg_full":"no","slider_visibility":"small-visibility,medium-visibility,large-visibility","main_padding":{"top":"","bottom":""},"content_bg_full":"no","image_rollover_icons":"default","bg_repeat":"default","header_bg_repeat":"repeat","displayed_menu":"default","slider_type":"no","slider":"0","wooslider":"0","elasticslider":"0","page_title_bar":"default","content_bg_repeat":"default"},"%avada_post_views_count%":"633","%avada_today_post_views_count%":"3","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2023-03-22","%_edit_lock%":"1684773250:20","%_edit_last%":"20","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_custom_link%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_fusion_google_fonts%":"","%fusion_builder_status%":"","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_thumbnail_id%":"74298","taxonomy=portfolio_category":"Cabin Rentals, Camp Store, Campgrounds, Laundry Facilities, Northwest Michigan Region, Online Reservations, Pet Friendly, Planned Activities, Pull-Through Sites, Sells Propane Gas, Swimming, Tent Sites","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":75275,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"The Pines Campground @ Camp Living Waters","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/the-pines-campground-camp-living-waters/\">The Pines Campground @ Camp Living Waters</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Sites available for your RV (full or partial hookup), tents or rent one of our A-Frame cabins, in our rural, wooded location. Plenty of nearby state land and orv trails. Beach access to nearby Stewart Lake, We're open May through October.<br /> 536 E. 6 Mile Rd. Luther, MI 49656","address":"536 E. 6 Mile Rd., Luther, MI 49656","location":{"lat":"44.077896","lng":"-85.791338","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/the-pines-campground-camp-living-waters/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Sites available for your RV (full or partial hookup), tents or rent one of our A-Frame cabins, in our rural, wooded location. Plenty of nearby state land and orv trails. Beach access to nearby Stewart Lake, We're open May through October.<br /> 536 E. 6 Mile Rd. Luther, MI 49656","post_content":"[mmi_map]\r\n\r\n <h1>The Pines Campground @ Camp Living Waters</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nSites available for your RV (full or partial hookup), tents or rent one of our A-Frame cabins, in our rural, wooded location. Plenty of nearby state land and orv trails. Beach access to nearby Stewart Lake, We're open May through October.\r\n\r\n536 E. 6 Mile Rd.\r\nLuther, MI 49656\r\n\r\n<strong>\r\n\r\nPhone: (231) 797-5107\r\n Website: <a href=\"https://www.camplivingwaters.org/campground\" target=\"_blank\" rel=\"noopener\">https://www.camplivingwaters.org/campground</a>\r\nemail: <a href=\"mailto:thepines@camplivingwaters.org\">thepines@camplivingwaters.org</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nFishing\r\nTent Sites\r\nCabin Rentals\r\nOnline Reservations\r\n\r\n\r\n     ","post_title":"The Pines Campground @ Camp Living Waters","post_link":"https://www.michiganrvandcampgrounds.org/member-info/the-pines-campground-camp-living-waters/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Pines Campground @ Camp Living Waters\" width=\"300\" height=\"199\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/05/c14-300x199.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"536 E. 6 Mile Rd., Luther, MI 49656","errors":[],"address_formatted":"536 E 6 Mile Rd, Luther, MI 49656, USA","lat":"44.077896","lng":"-85.791338","street_number":"536","street_name_long":"East 6 Mile Road","street_name_short":"E 6 Mile Rd","city":"Luther","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49656"},"%_mmi_phone%":"(231) 797-5107","%_mmi_url%":"https://www.camplivingwaters.org/campground","%_wpgmp_location_address%":"536 E. 6 Mile Rd., Luther, MI 49656","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_wpgmp_metabox_latitude%":"44.077896","%_wpgmp_metabox_longitude%":"-85.791338","%_fusion%":"","%avada_post_views_count%":"502","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"25-04-2024","%_wp_old_date%":"2023-05-30","%_thumbnail_id%":"29911","taxonomy=portfolio_category":"Cabin Rentals, Campgrounds, Fishing, Full Hook-Up, Northwest Michigan Region, Online Reservations, Swimming, Tent Sites","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":75457,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Enchanted Pebawma Lake Campground","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/enchanted-pebawma-lake-campground/\">Enchanted Pebawma Lake Campground</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Open May - Sept.30 (if weather allows thru Oct. 31). We are located in the Manistee National Forest on 52 acres. We are on a spring fed, no-wake lake, great for kayaking, canoeing & paddle boarding. We have a swimming beach, playground, fresh water, dump station, 40 electric and 10 non-electric sites. Very peaceful and relaxing.<br /> 5733 N 168th Ave. Walkerville, MI 49459","address":"5733 N 168th Ave., Walkerville, MI 49459","location":{"lat":"43.747663","lng":"-86.142984","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/enchanted-pebawma-lake-campground/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Open May - Sept.30 (if weather allows thru Oct. 31). We are located in the Manistee National Forest on 52 acres. We are on a spring fed, no-wake lake, great for kayaking, canoeing & paddle boarding. We have a swimming beach, playground, fresh water, dump station, 40 electric and 10 non-electric sites. Very peaceful and relaxing.<br /> 5733 N 168th Ave. Walkerville, MI 49459","post_content":"[mmi_map]\r\n\r\n <h1>Enchanted Pebawma Lake Campground</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nOpen May - Sept.30 (if weather allows thru Oct. 31). We are located in the Manistee National Forest on 52 acres. We are on a spring fed, no-wake lake, great for kayaking, canoeing & paddle boarding. We have a swimming beach, playground, fresh water, dump station, 40 electric and 10 non-electric sites. Very peaceful and relaxing.\r\n\r\n5733 N 168th Ave.\r\nWalkerville, MI 49459\r\n\r\n<strong>\r\n\r\nPhone: (616) 206-0923\r\n Website: <a href=\"http://www.enchantedlakecamping.com\" target=\"_blank\" rel=\"noopener\">www.enchantedlakecamping.com</a>\r\nemail: <a href=\"mailto:enchantedpebawmacampground@gmail.com\">enchantedpebawmacampground@gmail.com</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nSwimming\r\nFishing\r\nTent Sites\r\n\r\n\r\n     ","post_title":"Enchanted Pebawma Lake Campground","post_link":"https://www.michiganrvandcampgrounds.org/member-info/enchanted-pebawma-lake-campground/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Enchanted Pebawma Lake Campground\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2022/01/c2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"5733 N 168th Ave., Walkerville, MI 49459","errors":[],"address_formatted":"5733 N 168th Ave, Walkerville, MI 49459, USA","lat":"43.747663","lng":"-86.142984","street_number":"5733","street_name_long":"North 168th Avenue","street_name_short":"N 168th Ave","city":"Walkerville","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49459"},"%_mmi_phone%":"(616) 206-0923","%_mmi_url%":"www.enchantedlakecamping.com","%_wpgmp_location_address%":"5733 N 168th Ave., Walkerville, MI 49459","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_wpgmp_metabox_latitude%":"43.747663","%_wpgmp_metabox_longitude%":"-86.142984","%_fusion%":"","%avada_post_views_count%":"422","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"25-04-2024","%_wp_old_date%":"2023-07-27","%_thumbnail_id%":"74214","taxonomy=portfolio_category":"Campgrounds, Fishing, Northwest Michigan Region, Swimming, Tent Sites","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":75524,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"The Bluffs on Manistee Lake &#8211; RV","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/the-bluffs-on-manistee-lake-rv/\">The Bluffs on Manistee Lake &#8211; RV</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Discover the beauty on top the bluff overlooking Manistee Lake! Michigan's newest 55+ RV park. Extra large sites with concrete patios. Spacious clubhouse with heated pool, hottub, laundry facilities and beautiful bathhouse. Close to Lake Michigan beaches, historic downtown, world-class fishing, Little River Casino and more...<br /> 956 Tennessee Ave. Manistee, MI 49660","address":"956 Tennessee Ave., Manistee, MI 49660","location":{"lat":"44.2365547","lng":"-86.2958313","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/the-bluffs-on-manistee-lake-rv/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Discover the beauty on top the bluff overlooking Manistee Lake! Michigan's newest 55+ RV park. Extra large sites with concrete patios. Spacious clubhouse with heated pool, hottub, laundry facilities and beautiful bathhouse. Close to Lake Michigan beaches, historic downtown, world-class fishing, Little River Casino and more...<br /> 956 Tennessee Ave. Manistee, MI 49660","post_content":"[mmi_map]\r\n\r\n <h1>The Bluffs on Manistee Lake - RV</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nDiscover the beauty on top the bluff overlooking Manistee Lake! Michigan's newest 55+ RV park. Extra large sites with concrete patios. Spacious clubhouse with heated pool, hottub, laundry facilities and beautiful bathhouse. Close to Lake Michigan beaches, historic downtown, world-class fishing, Little River Casino and more...\r\n\r\n956 Tennessee Ave.\r\nManistee, MI 49660\r\n\r\n<strong>\r\n\r\nPhone: (231) 887-4512\r\nFax: (231) 887-4513\r\nWebsite: <a href=\"http://www.thebluffsonmanisteelake.com\" target=\"_blank\" rel=\"noopener\">www.thebluffsonmanisteelake.com</a>\r\nemail: <a href=\"mailto:info@thebluffsonmanisteelake.com\">info@thebluffsonmanisteelake.com</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nLaundry Facilities\r\nFishing\r\nRecreation Facilities\r\nPlanned Activities\r\nCable TV\r\nWiFi Available\r\nPet Friendly\r\nPull-Through Sites\r\nYear-Round Camping\r\nHandicap Accessible\r\nOnline Reservations\r\n\r\n\r\n     ","post_title":"The Bluffs on Manistee Lake &#8211; RV","post_link":"https://www.michiganrvandcampgrounds.org/member-info/the-bluffs-on-manistee-lake-rv/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Bluffs on Manistee Lake &#8211; RV\" width=\"300\" height=\"248\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2022/01/c26-300x248.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"956 Tennessee Ave., Manistee, MI 49660","errors":[],"address_formatted":"956 Tennessee Ave, Manistee, MI 49660, USA","lat":"44.2365547","lng":"-86.2958313","street_number":"956","street_name_long":"Tennessee Avenue","street_name_short":"Tennessee Ave","city":"Manistee","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49660"},"%_mmi_phone%":"(231) 887-4512","%_mmi_url%":"www.thebluffsonmanisteelake.com","%_wpgmp_location_address%":"956 Tennessee Ave., Manistee, MI 49660","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":{"fimg":{"width":"","height":""},"bg_full":"no","display_header":"yes","header_bg_full":"no","slider_visibility":"small-visibility,medium-visibility,large-visibility","main_padding":{"top":"","bottom":""},"content_bg_full":"no","image_rollover_icons":"default","bg_repeat":"default","header_bg_repeat":"repeat","displayed_menu":"default","slider_type":"no","slider":"0","wooslider":"0","elasticslider":"0","page_title_bar":"default","content_bg_repeat":"default"},"%avada_post_views_count%":"2324","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-01-31","%_wpgmp_metabox_latitude%":"44.2365547","%_wpgmp_metabox_longitude%":"-86.2958313","%_edit_lock%":"1684955109:20","%_edit_last%":"20","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_custom_link%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_fusion_google_fonts%":"","%fusion_builder_status%":"","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_thumbnail_id%":"74241","taxonomy=portfolio_category":"Cable TV, Campgrounds, Fishing, Full Hook-Up, Handicap Accessible, Laundry Facilities, Northwest Michigan Region, Online Reservations, Pet Friendly, Planned Activities, Pull-Through Sites, Recreation Facilities, Swimming, WiFi Available, Year-Round Camping","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74314,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Twin Oaks Campground &#038; Cabins","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/twin-oaks-campground-cabins/\">Twin Oaks Campground &#038; Cabins</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Campground offering RV & tent sites as well as cabins. Wooded, family friendly par. Open April &#x2013; November. E-mail for more information twinoakscg@gmail.com.<br /> 233 Moss Road Wellston, MI 49689","address":"233 Moss Road, Wellston, MI 49689","location":{"lat":"44.2351367","lng":"-85.888546","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/twin-oaks-campground-cabins/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Campground offering RV & tent sites as well as cabins. Wooded, family friendly par. Open April &#x2013; November. E-mail for more information twinoakscg@gmail.com.<br /> 233 Moss Road Wellston, MI 49689","post_content":"[mmi_map]\r\n\r\n <h1>Twin Oaks Campground & Cabins</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nCampground offering RV & tent sites as well as cabins. Wooded, family friendly par. Open April &#x2013; November. E-mail for more information twinoakscg@gmail.com.\r\n\r\n233 Moss Road\r\nWellston, MI 49689\r\n\r\n<strong>\r\n\r\nPhone: 231-848-4124\r\n Website: <a href=\"http://www.twinoakscamping.com\" target=\"_blank\" rel=\"noopener\">www.twinoakscamping.com</a>\r\nemail: <a href=\"mailto:twinoakscg@gmail.com\">twinoakscg@gmail.com</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nLaundry Facilities\r\nRecreation Facilities\r\nPlanned Activities\r\nCamp Store\r\nWiFi Available\r\nPet Friendly\r\nPull-Through Sites\r\nTent Sites\r\nCabin Rentals\r\nCall For Information\r\n\r\n\r\n     ","post_title":"Twin Oaks Campground &#038; Cabins","post_link":"https://www.michiganrvandcampgrounds.org/member-info/twin-oaks-campground-cabins/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Twin Oaks Campground &#038; Cabins\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2023/05/c12-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"233 Moss Road, Wellston, MI 49689","errors":[],"address_formatted":"233 Moss Rd, Wellston, MI 49689, USA","lat":"44.2351367","lng":"-85.888546","street_number":"233","street_name_long":"Moss Road","street_name_short":"Moss Rd","city":"Wellston","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49689"},"%_mmi_phone%":"231-848-4124","%_mmi_url%":"www.twinoakscamping.com","%_wpgmp_location_address%":"233 Moss Road, Wellston, MI 49689","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":{"fimg":{"width":"","height":""},"bg_full":"no","display_header":"yes","header_bg_full":"no","slider_visibility":"small-visibility,medium-visibility,large-visibility","main_padding":{"top":"","bottom":""},"content_bg_full":"no","image_rollover_icons":"default","bg_repeat":"default","header_bg_repeat":"repeat","displayed_menu":"default","slider_type":"no","slider":"0","wooslider":"0","elasticslider":"0","page_title_bar":"default","content_bg_repeat":"default"},"%avada_post_views_count%":"1815","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-01-31","%_edit_lock%":"1684954679:20","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"44.2351367","%_wpgmp_metabox_longitude%":"-85.888546","%_wpgmp_metabox_custom_link%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_fusion_google_fonts%":"","%fusion_builder_status%":"","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_edit_last%":"20","%_yoast_wpseo_wordproof_timestamp%":"","%_thumbnail_id%":"75449","taxonomy=portfolio_category":"Cabin Rentals, Camp Store, Campgrounds, Full Hook-Up, Laundry Facilities, Northwest Michigan Region, Pet Friendly, Planned Activities, Pull-Through Sites, Recreation Facilities, Swimming, Tent Sites, WiFi Available","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74319,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Traverse Bay RV Resort","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/traverse-bay-rv-resort/\">Traverse Bay RV Resort</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Traverse Bay RV Resort is an adult-oriented RV park located in the heart of Northern Michigan. This upscale RV resort can be your temporary or permanent &#x201C;up north&#x201D; retreat. Individual RV sites are available for purchase or can be rented on a daily, weekly or monthly basis and are restricted to Class A, Class C and Fifth Wheels only.<br /> 5555 M-72 East Williamsburg, MI 49690","address":"5555 M-72 East, Williamsburg, MI 49690","location":{"lat":"44.7746552","lng":"-85.4634241","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/traverse-bay-rv-resort/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Traverse Bay RV Resort is an adult-oriented RV park located in the heart of Northern Michigan. This upscale RV resort can be your temporary or permanent &#x201C;up north&#x201D; retreat. Individual RV sites are available for purchase or can be rented on a daily, weekly or monthly basis and are restricted to Class A, Class C and Fifth Wheels only.<br /> 5555 M-72 East Williamsburg, MI 49690","post_content":"[mmi_map]\r\n\r\n <h1>Traverse Bay RV Resort</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nTraverse Bay RV Resort is an adult-oriented RV park located in the heart of Northern Michigan. This upscale RV resort can be your temporary or permanent &#x201C;up north&#x201D; retreat. Individual RV sites are available for purchase or can be rented on a daily, weekly or monthly basis and are restricted to Class A, Class C and Fifth Wheels only.\r\n\r\n5555 M-72 East\r\nWilliamsburg, MI 49690\r\n\r\n<strong>\r\n\r\nPhone: (231) 938-5800\r\nFax: (231) 938-5806 (seasonal)\r\nWebsite: <a href=\"http://www.traversebayrv.com\" target=\"_blank\" rel=\"noopener\">www.traversebayrv.com</a>\r\nemail: <a href=\"mailto:office@traversebayrv.com\">office@traversebayrv.com</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nLaundry Facilities\r\nRecreation Facilities\r\nPlanned Activities\r\nCable TV\r\nWiFi Available\r\n\r\n\r\n     ","post_title":"Traverse Bay RV Resort","post_link":"https://www.michiganrvandcampgrounds.org/member-info/traverse-bay-rv-resort/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Traverse Bay RV Resort\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2022/01/c27-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"5555 M-72 East, Williamsburg, MI 49690","errors":[],"address_formatted":"5555 M-72, Williamsburg, MI 49690, USA","lat":"44.7746552","lng":"-85.4634241","street_number":"5555","street_name_long":"Michigan 72","street_name_short":"M-72","city":"Williamsburg","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49690"},"%_mmi_phone%":"(231) 938-5800","%_mmi_url%":"www.traversebayrv.com","%_wpgmp_location_address%":"5555 M-72 East, Williamsburg, MI 49690","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":"","%avada_post_views_count%":"1639","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-01-31","%_edit_lock%":"1647542176:11","%_wpgmp_metabox_latitude%":"44.7746552","%_wpgmp_metabox_longitude%":"-85.4634241","%_thumbnail_id%":"74217","taxonomy=portfolio_category":"Cable TV, Campgrounds, Full Hook-Up, Laundry Facilities, Northwest Michigan Region, Planned Activities, Recreation Facilities, Swimming, WiFi Available","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74324,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Sun Outdoors Petoskey Bay Harbor","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/sun-outdoors-petoskey-bay-harbor/\">Sun Outdoors Petoskey Bay Harbor</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Our RV resort is sure to deliver a wonderful summer experience. With 26 resort acres, 135 RV sites and 16 cottages, that include lakeview lots, you can discover the getaway for you and your family. Book your vacation rentals here. Enjoy a semi-private resort experience with dozens of resort luxuries, including a 9 hole putting green. Our community is located in the Lower Peninsula &#x2013; in what is known as the &#x201C;Crown Jewel of Michigan,&#x201D; and is a stone&#x2019;s throw from world class fishing and hiking.<br /> 5505 Charlevoix Ave. Petoskey, MI 49770","address":"5505 Charlevoix Ave., Petoskey, MI 49770","location":{"lat":"45.3581558","lng":"-85.0543891","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/sun-outdoors-petoskey-bay-harbor/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Our RV resort is sure to deliver a wonderful summer experience. With 26 resort acres, 135 RV sites and 16 cottages, that include lakeview lots, you can discover the getaway for you and your family. Book your vacation rentals here. Enjoy a semi-private resort experience with dozens of resort luxuries, including a 9 hole putting green. Our community is located in the Lower Peninsula &#x2013; in what is known as the &#x201C;Crown Jewel of Michigan,&#x201D; and is a stone&#x2019;s throw from world class fishing and hiking.<br /> 5505 Charlevoix Ave. Petoskey, MI 49770","post_content":"[mmi_map]\r\n\r\n <h1>Sun Outdoors Petoskey Bay Harbor</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nOur RV resort is sure to deliver a wonderful summer experience. With 26 resort acres, 135 RV sites and 16 cottages, that include lakeview lots, you can discover the getaway for you and your family. Book your vacation rentals here. Enjoy a semi-private resort experience with dozens of resort luxuries, including a 9 hole putting green. Our community is located in the Lower Peninsula &#x2013; in what is known as the &#x201C;Crown Jewel of Michigan,&#x201D; and is a stone&#x2019;s throw from world class fishing and hiking.\r\n\r\n5505 Charlevoix Ave.\r\nPetoskey, MI 49770\r\n\r\n<strong>\r\n\r\nPhone: (844) 570-0999\r\nFax: (248) 208-2644\r\nWebsite: <a href=\"http://www.petoskeyrvresort.com\" target=\"_blank\" rel=\"noopener\">www.petoskeyrvresort.com</a>\r\nemail: <a href=\"mailto:petoskeyrv@suncommunities.com\">petoskeyrv@suncommunities.com</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nLaundry Facilities\r\nFishing\r\nRecreation Facilities\r\nPlanned Activities\r\nCamp Store\r\nCable TV\r\nWiFi Available\r\nPet Friendly\r\nCabin Rentals\r\nHandicap Accessible\r\nOnline Reservations\r\nCall For Information\r\n\r\n\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2021/04/Motor-Coach-09-168_4898437618_o-edit_PetoskeyRVResort_featured.jpg\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2019/10/MG_0071_PetoskeyRVResort_additional1.jpg\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2019/10/MG_0079_PetoskeyRVResort_additional2.jpg\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2019/10/IMG_1327_PetoskeyRVResort_additional3.jpg\" />\r\n ","post_title":"Sun Outdoors Petoskey Bay Harbor","post_link":"https://www.michiganrvandcampgrounds.org/member-info/sun-outdoors-petoskey-bay-harbor/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sun Outdoors Petoskey Bay Harbor\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2021/04/Motor-Coach-09-168_4898437618_o-edit_PetoskeyRVResort_featured-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"5505 Charlevoix Ave., Petoskey, MI 49770","errors":[],"address_formatted":"5505 Charlevoix Ave, Petoskey, MI 49770, USA","lat":"45.3581558","lng":"-85.0543891","street_number":"5505","street_name_long":"Charlevoix Avenue","street_name_short":"Charlevoix Ave","city":"Petoskey","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49770"},"%_mmi_phone%":"(844) 570-0999","%_mmi_url%":"www.petoskeyrvresort.com","%_wpgmp_location_address%":"5505 Charlevoix Ave., Petoskey, MI 49770","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":"","%avada_post_views_count%":"2404","%avada_today_post_views_count%":"5","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-01-31","%_wpgmp_metabox_latitude%":"45.3581558","%_wpgmp_metabox_longitude%":"-85.0543891","%_wp_old_slug%":"petoskey-rv-resort","%_edit_lock%":"1684786668:20","%_thumbnail_id%":"73545","taxonomy=portfolio_category":"Cabin Rentals, Cable TV, Camp Store, Campgrounds, Fishing, Full Hook-Up, Handicap Accessible, Laundry Facilities, Northwest Michigan Region, Online Reservations, Pet Friendly, Planned Activities, Recreation Facilities, Swimming, WiFi Available","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74313,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Dunes Harbor Family Camp","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/dunes-harbor-family-camp/\">Dunes Harbor Family Camp</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Dunes Harbor Family Camp is a campground near Silver Lake where your family can reconnect with each other and the beauty of Michigan. Located on the shores of Lake Holiday, only one mile away from the Sand Dune ORV entrance, this value-based Christian environment gives your family the chance to get away from the busyness of life. You&#x2019;ll enjoy clean, modern facilities and exceptional staff that will make your stay memorable. Full Hook-up, water/electric, and group sites available.<br /> 2722 North Ridge Road Mears, MI 49436","address":"2722 North Ridge Road, Mears, MI 49436","location":{"lat":"43.7041997","lng":"-86.4856292","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/dunes-harbor-family-camp/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Dunes Harbor Family Camp is a campground near Silver Lake where your family can reconnect with each other and the beauty of Michigan. Located on the shores of Lake Holiday, only one mile away from the Sand Dune ORV entrance, this value-based Christian environment gives your family the chance to get away from the busyness of life. You&#x2019;ll enjoy clean, modern facilities and exceptional staff that will make your stay memorable. Full Hook-up, water/electric, and group sites available.<br /> 2722 North Ridge Road Mears, MI 49436","post_content":"[mmi_map]\r\n\r\n<img class=\"alignright wp-image-25447\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2018/05/DHFClogo.jpg\" width=\"180\" /><h1>Dunes Harbor Family Camp</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nDunes Harbor Family Camp is a campground near Silver Lake where your family can reconnect with each other and the beauty of Michigan. Located on the shores of Lake Holiday, only one mile away from the Sand Dune ORV entrance, this value-based Christian environment gives your family the chance to get away from the busyness of life. You&#x2019;ll enjoy clean, modern facilities and exceptional staff that will make your stay memorable. Full Hook-up, water/electric, and group sites available.\r\n\r\n2722 North Ridge Road\r\nMears, MI 49436\r\n\r\n<strong>\r\n\r\nPhone: 231-873-3662\r\nFax: 231-873-0283\r\nWebsite: <a href=\"http://www.dunesharbor.org\" target=\"_blank\" rel=\"noopener\">http://www.dunesharbor.org</a>\r\nemail: <a href=\"mailto:dunesharbor@graceadventures.org\">dunesharbor@graceadventures.org</a>\r\n</strong>\r\n\r\n<a href=\"http://www.michiganrvandcampgrounds.org/wp-content/uploads/gravity_forms/9-1fce8a08c900e531d1cd9da622132191/2016/06/Site-Map.pdf \" target=\"_blank\" rel=\"noopener noreferrer\"><img class=\"size-full wp-image-25829 alignright\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/04/sitemap-1.jpg\" alt=\"sitemap\" width=\"150\" height=\"180\" /></a><b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nLaundry Facilities\r\nFishing\r\nRecreation Facilities\r\nPlanned Activities\r\nCamp Store\r\nWiFi Available\r\nPet Friendly\r\nSells Propane Gas\r\nBoat Canoe Rentals\r\nPull-Through Sites\r\nMembers Only\r\nTent Sites\r\nCabin Rentals\r\nHandicap Accessible\r\nOnline Reservations\r\nCall For Information\r\n\r\n\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2021/04/dunes-featured.jpg\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2019/07/Dunes-Harbor-aerial-view.jpg\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2019/07/Dunes-Harbor-group-walk.jpg\" />\r\n  ","post_title":"Dunes Harbor Family Camp","post_link":"https://www.michiganrvandcampgrounds.org/member-info/dunes-harbor-family-camp/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Dunes Harbor Family Camp\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2021/04/dunes-featured-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"2722 North Ridge Road, Mears, MI 49436","errors":[],"address_formatted":"2722 N Ridge Rd, Mears, MI 49436, USA","lat":"43.7041997","lng":"-86.4856292","street_number":"2722","street_name_long":"North Ridge Road","street_name_short":"N Ridge Rd","city":"Mears","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49436"},"%_mmi_phone%":"231-873-3662","%_mmi_url%":"http://www.dunesharbor.org","%_wpgmp_location_address%":"2722 North Ridge Road, Mears, MI 49436","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":"","%avada_post_views_count%":"2216","%avada_today_post_views_count%":"4","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-01-31","%_wpgmp_metabox_latitude%":"43.7041997","%_wpgmp_metabox_longitude%":"-86.4856292","%_thumbnail_id%":"73541","taxonomy=portfolio_category":"Boat Canoe Rentals, Cabin Rentals, Camp Store, Campgrounds, Fishing, Full Hook-Up, Handicap Accessible, Laundry Facilities, Members Only, Northwest Michigan Region, Online Reservations, Pet Friendly, Planned Activities, Pull-Through Sites, Recreation Facilities, Sells Propane Gas, Swimming, Tent Sites, WiFi Available","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74307,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Bluegill Lake Family Camping Resort","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/bluegill-lake-family-camping-resort/\">Bluegill Lake Family Camping Resort</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Mecosta's only family and pet friendly privately owned campground. Offering large and mature sites and waterfront camping cabins in a clean, quiet environment. Guests can \"Catch the Fun\" with activities and themed weekends, private, springfed lake boasting water inflatables and catch & release fishing, hiking, fun cycles, full service campstore and much more. Open mid-April to mid-October. Office hrs 9 am - 9 pm daily. \"Bluegill Lake, Catch the Fun\"<br /> 15854 Pretty Lake Drive Mecosta, MI 49332","address":"15854 Pretty Lake Drive, Mecosta, MI 49332","location":{"lat":"43.6956923","lng":"-85.2269116","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/bluegill-lake-family-camping-resort/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Mecosta's only family and pet friendly privately owned campground. Offering large and mature sites and waterfront camping cabins in a clean, quiet environment. Guests can \"Catch the Fun\" with activities and themed weekends, private, springfed lake boasting water inflatables and catch & release fishing, hiking, fun cycles, full service campstore and much more. Open mid-April to mid-October. Office hrs 9 am - 9 pm daily. \"Bluegill Lake, Catch the Fun\"<br /> 15854 Pretty Lake Drive Mecosta, MI 49332","post_content":"[mmi_map]\r\n\r\n <h1>Bluegill Lake Family Camping Resort</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nMecosta's only family and pet friendly privately owned campground. Offering large and mature sites and waterfront camping cabins in a clean, quiet environment. Guests can \"Catch the Fun\" with activities and themed weekends, private, springfed lake boasting water inflatables and catch & release fishing, hiking, fun cycles, full service campstore and much more. Open mid-April to mid-October. Office hrs 9 am - 9 pm daily. \"Bluegill Lake, Catch the Fun\"\r\n\r\n15854 Pretty Lake Drive\r\nMecosta, MI 49332\r\n\r\n<strong>\r\n\r\nPhone: (231) 972-4455\r\n Website: <a href=\"http://www.bluegillcamping.com\" target=\"_blank\" rel=\"noopener\">www.bluegillcamping.com</a>\r\nemail: <a href=\"mailto:information@bluegillcamping.com\">information@bluegillcamping.com</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nFishing\r\nRecreation Facilities\r\nPlanned Activities\r\nCamp Store\r\nWiFi Available\r\nPet Friendly\r\nSells Propane Gas\r\nBoat Canoe Rentals\r\nPull-Through Sites\r\nTent Sites\r\nCabin Rentals\r\nCall For Information\r\n\r\n\r\n     ","post_title":"Bluegill Lake Family Camping Resort","post_link":"https://www.michiganrvandcampgrounds.org/member-info/bluegill-lake-family-camping-resort/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Bluegill Lake Family Camping Resort\" width=\"300\" height=\"210\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/05/c11-300x210.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"15854 Pretty Lake Drive, Mecosta, MI 49332","errors":[],"address_formatted":"15854 Pretty Lake Dr, Mecosta, MI 49332, USA","lat":"43.6956923","lng":"-85.2269116","street_number":"15854","street_name_long":"Pretty Lake Drive","street_name_short":"Pretty Lake Dr","city":"Mecosta","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49332"},"%_mmi_phone%":"(231) 972-4455","%_mmi_url%":"www.bluegillcamping.com","%_wpgmp_location_address%":"15854 Pretty Lake Drive, Mecosta, MI 49332","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":"","%avada_post_views_count%":"1729","%avada_today_post_views_count%":"3","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-01-31","%_wpgmp_metabox_latitude%":"43.6956923","%_wpgmp_metabox_longitude%":"-85.2269116","%_thumbnail_id%":"29920","taxonomy=portfolio_category":"Boat Canoe Rentals, Cabin Rentals, Camp Store, Campgrounds, Fishing, Full Hook-Up, Northwest Michigan Region, Pet Friendly, Planned Activities, Pull-Through Sites, Recreation Facilities, Sells Propane Gas, Swimming, Tent Sites, WiFi Available","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74295,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Poncho&#8217;s Pond RV Park","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/ponchos-pond-rv-park/\">Poncho&#8217;s Pond RV Park</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Open April 1-November 1. Indoor pool, fitness center, immaculate restrooms. Located 2 miles from beautiful Lake Michigan. Walking distance to stores and restaurants. Golf cart rentals available. Firewood is available at the campground.<br /> 5335 West Wallace Lane Ludington, MI 49431","address":"5335 West Wallace Lane, Ludington, MI 49431","location":{"lat":"43.9529965","lng":"-86.411879","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/ponchos-pond-rv-park/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Open April 1-November 1. Indoor pool, fitness center, immaculate restrooms. Located 2 miles from beautiful Lake Michigan. Walking distance to stores and restaurants. Golf cart rentals available. Firewood is available at the campground.<br /> 5335 West Wallace Lane Ludington, MI 49431","post_content":"[mmi_map]\r\n\r\n <h1>Poncho's Pond RV Park</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nOpen April 1-November 1. Indoor pool, fitness center, immaculate restrooms. Located 2 miles from beautiful Lake Michigan. Walking distance to stores and restaurants. Golf cart rentals available. Firewood is available at the campground.\r\n\r\n5335 West Wallace Lane\r\nLudington, MI 49431\r\n\r\n<strong>\r\n\r\nPhone: (231) 845-6655\r\nFax: (231) 845-5538\r\nWebsite: <a href=\"http://www.poncho.com\" target=\"_blank\" rel=\"noopener\">www.poncho.com</a>\r\nemail: <a href=\"mailto:poncho@poncho.com\">poncho@poncho.com</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nLaundry Facilities\r\nFishing\r\nRecreation Facilities\r\nPlanned Activities\r\nCamp Store\r\nCable TV\r\nWiFi Available\r\nPet Friendly\r\nSells Propane Gas\r\nPull-Through Sites\r\nTent Sites\r\nCabin Rentals\r\nHandicap Accessible\r\nOnline Reservations\r\n\r\n\r\n     ","post_title":"Poncho&#8217;s Pond RV Park","post_link":"https://www.michiganrvandcampgrounds.org/member-info/ponchos-pond-rv-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Poncho&#8217;s Pond RV Park\" width=\"300\" height=\"210\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/05/c11-300x210.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"5335 West Wallace Lane, Ludington, MI 49431","errors":[],"address_formatted":"5335 W wallace Ln, Ludington, MI 49431, USA","lat":"43.9529965","lng":"-86.411879","street_number":"5335","street_name_long":"West wallace Lane","street_name_short":"W wallace Ln","city":"Ludington","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49431"},"%_mmi_phone%":"(231) 845-6655","%_mmi_url%":"www.poncho.com","%_wpgmp_location_address%":"5335 West Wallace Lane, Ludington, MI 49431","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":"","%avada_post_views_count%":"1394","%avada_today_post_views_count%":"3","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-01-31","%_wpgmp_metabox_latitude%":"43.9529965","%_wpgmp_metabox_longitude%":"-86.411879","%_thumbnail_id%":"29920","taxonomy=portfolio_category":"Cabin Rentals, Cable TV, Camp Store, Campgrounds, Fishing, Full Hook-Up, Handicap Accessible, Laundry Facilities, Northwest Michigan Region, Online Reservations, Pet Friendly, Planned Activities, Pull-Through Sites, Recreation Facilities, Sells Propane Gas, Swimming, Tent Sites, WiFi Available","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74297,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Snow Lake Kampground","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/snow-lake-kampground/\">Snow Lake Kampground</a></div>\r\n</div>","content":"Northwest Michigan Region<br />We are non-membership, family-owned and operated campground with 309 sites. Tents to big rigs. Overnight and seasonal camping.  Restaurant, cabins, store, game room, swimming pool, wading pool, hot tub, sauna, fitness room, 55-acre lake and 3-acre pond, playground, mini-golf, boat rentals, recreation areas, laundry facilities, worship services, theme weekends, activities and wagon rides.<br /> 644 East Snows Lake Road Fenwick, MI 48834","address":"644 East Snows Lake Road, Fenwick, MI 48834","location":{"lat":"43.1331221","lng":"-85.0613265","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/snow-lake-kampground/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />We are non-membership, family-owned and operated campground with 309 sites. Tents to big rigs. Overnight and seasonal camping.  Restaurant, cabins, store, game room, swimming pool, wading pool, hot tub, sauna, fitness room, 55-acre lake and 3-acre pond, playground, mini-golf, boat rentals, recreation areas, laundry facilities, worship services, theme weekends, activities and wagon rides.<br /> 644 East Snows Lake Road Fenwick, MI 48834","post_content":"[mmi_map]\r\n\r\n <h1>Snow Lake Kampground</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nWe are non-membership, family-owned and operated campground with 309 sites. Tents to big rigs. Overnight and seasonal camping.  Restaurant, cabins, store, game room, swimming pool, wading pool, hot tub, sauna, fitness room, 55-acre lake and 3-acre pond, playground, mini-golf, boat rentals, recreation areas, laundry facilities, worship services, theme weekends, activities and wagon rides.\r\n\r\n644 East Snows Lake Road\r\nFenwick, MI 48834\r\n\r\n<strong>\r\n\r\nPhone: (989) 248-3224\r\nFax: (989) 248-3465\r\nWebsite: <a href=\"http://www.snowlakekampground.com\" target=\"_blank\" rel=\"noopener\">www.snowlakekampground.com</a>\r\nemail: <a href=\"mailto:camp@snowlakekampground.com\">camp@snowlakekampground.com</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nLaundry Facilities\r\nFishing\r\nRecreation Facilities\r\nPlanned Activities\r\nCamp Store\r\nWiFi Available\r\nPet Friendly\r\nSells Propane Gas\r\nBoat Canoe Rentals\r\nPull-Through Sites\r\nTent Sites\r\nCabin Rentals\r\nHandicap Accessible\r\nCall For Information\r\n\r\n\r\n     ","post_title":"Snow Lake Kampground","post_link":"https://www.michiganrvandcampgrounds.org/member-info/snow-lake-kampground/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Snow Lake Kampground\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2022/01/c15-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"644 East Snows Lake Road, Fenwick, MI 48834","errors":[],"address_formatted":"644 E Snows Lake Rd, Fenwick, MI 48834, USA","lat":"43.1331221","lng":"-85.0613265","street_number":"644","street_name_long":"East Snows Lake Road","street_name_short":"E Snows Lake Rd","city":"Fenwick","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"48834"},"%_mmi_phone%":"(989) 248-3224","%_mmi_url%":"www.snowlakekampground.com","%_wpgmp_location_address%":"644 East Snows Lake Road, Fenwick, MI 48834","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":"","%avada_post_views_count%":"1262","%avada_today_post_views_count%":"4","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-01-31","%_wpgmp_metabox_latitude%":"43.1331221","%_wpgmp_metabox_longitude%":"-85.0613265","%_thumbnail_id%":"74243","taxonomy=portfolio_category":"Boat Canoe Rentals, Cabin Rentals, Camp Store, Campgrounds, Fishing, Full Hook-Up, Handicap Accessible, Laundry Facilities, Northwest Michigan Region, Pet Friendly, Planned Activities, Pull-Through Sites, Recreation Facilities, Sells Propane Gas, Swimming, Tent Sites, WiFi Available","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74280,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Indigo Bluffs RV Park &#038; Resort","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/indigo-bluffs-rv-park-resort/\">Indigo Bluffs RV Park &#038; Resort</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Indigo delivers three unique experiences to accommodate all types and classes of RVs and towable campers:  RV Park, RV Resort, and Cottages. Pool, WiFi, Bath/Laundry facilities, ClubRoom, Pavilion, Store, and Playground. Sleeping Bear Dunes and Lake Michigan beaches at your doorstep. Enjoy numerous hiking/biking trails and inland water to paddle and float. Canopy of mature hardwoods. Full Hook-Up, Water/Electric, Pull-Thru sites and rustic cabins. Daily, monthly seasonal rentals and ownership.<br /> 6760 West Empire Highway Empire, MI 49630","address":"6760 West Empire Highway, Empire, MI 49630","location":{"lat":"44.8086877","lng":"-85.9932989","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/indigo-bluffs-rv-park-resort/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Indigo delivers three unique experiences to accommodate all types and classes of RVs and towable campers:  RV Park, RV Resort, and Cottages. Pool, WiFi, Bath/Laundry facilities, ClubRoom, Pavilion, Store, and Playground. Sleeping Bear Dunes and Lake Michigan beaches at your doorstep. Enjoy numerous hiking/biking trails and inland water to paddle and float. Canopy of mature hardwoods. Full Hook-Up, Water/Electric, Pull-Thru sites and rustic cabins. Daily, monthly seasonal rentals and ownership.<br /> 6760 West Empire Highway Empire, MI 49630","post_content":"[mmi_map]\r\n\r\n<img class=\"alignright wp-image-25447\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2021/02/indigobluff-bear_4c.jpg\" width=\"180\" /><h1>Indigo Bluffs RV Park & Resort</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nIndigo delivers three unique experiences to accommodate all types and classes of RVs and towable campers:  RV Park, RV Resort, and Cottages. Pool, WiFi, Bath/Laundry facilities, ClubRoom, Pavilion, Store, and Playground. Sleeping Bear Dunes and Lake Michigan beaches at your doorstep. Enjoy numerous hiking/biking trails and inland water to paddle and float. Canopy of mature hardwoods. Full Hook-Up, Water/Electric, Pull-Thru sites and rustic cabins. Daily, monthly seasonal rentals and ownership.\r\n\r\n6760 West Empire Highway\r\nEmpire, MI 49630\r\n\r\n<strong>\r\n\r\nPhone: (231) 326-5050\r\nFax: (231) 326-5711\r\nWebsite: <a href=\"http://www.indigobluffs.com\" target=\"_blank\" rel=\"noopener\">www.indigobluffs.com</a>\r\nemail: <a href=\"mailto:visitus@indigobluffs.com\">visitus@indigobluffs.com</a>\r\n</strong>\r\n\r\n<a href=\"http://www.michiganrvandcampgrounds.org/wp-content/uploads/2021/02/Indigo-Bluffs-2021-Map.pdf \" target=\"_blank\" rel=\"noopener noreferrer\"><img class=\"size-full wp-image-25829 alignright\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/04/sitemap-1.jpg\" alt=\"sitemap\" width=\"150\" height=\"180\" /></a><b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nLaundry Facilities\r\nRecreation Facilities\r\nCamp Store\r\nWiFi Available\r\nPet Friendly\r\nSells Propane Gas\r\nPull-Through Sites\r\nTent Sites\r\nCabin Rentals\r\nHandicap Accessible\r\nOnline Reservations\r\nCall For Information\r\n\r\n\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2017/09/IndigoBluffs4.jpeg\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2017/09/IndigoBluffs1.jpeg\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2017/09/IndigoBluffs2.jpeg\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2017/09/IndigoBluffs3.jpeg\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2021/02/Drone-RVR-Entry.png\" />\r\n","post_title":"Indigo Bluffs RV Park &#038; Resort","post_link":"https://www.michiganrvandcampgrounds.org/member-info/indigo-bluffs-rv-park-resort/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Indigo Bluffs RV Park &#038; Resort\" width=\"300\" height=\"214\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2017/09/IndigoBluffs4-300x214.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"6760 West Empire Highway, Empire, MI 49630","errors":[],"address_formatted":"6760 W Empire Hwy, Empire, MI 49630, USA","lat":"44.8086877","lng":"-85.9932989","street_number":"6760","street_name_long":"West Empire Highway","street_name_short":"W Empire Hwy","city":"Empire","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49630"},"%_mmi_phone%":"(231) 326-5050","%_mmi_url%":"www.indigobluffs.com","%_wpgmp_location_address%":"6760 West Empire Highway, Empire, MI 49630","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":"","%avada_post_views_count%":"2493","%avada_today_post_views_count%":"7","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-01-31","%_wpgmp_metabox_latitude%":"44.8086877","%_wpgmp_metabox_longitude%":"-85.9932989","%_edit_lock%":"1684850614:1","%_thumbnail_id%":"49638","taxonomy=portfolio_category":"Cabin Rentals, Camp Store, Campgrounds, Full Hook-Up, Handicap Accessible, Laundry Facilities, Northwest Michigan Region, Online Reservations, Pet Friendly, Pull-Through Sites, Recreation Facilities, Sells Propane Gas, Swimming, Tent Sites, WiFi Available","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74283,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Adventure Bound Camping Resorts &#8211; West Michigan","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/adventure-bound-camping-resorts-west-michigan/\">Adventure Bound Camping Resorts &#8211; West Michigan</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Enjoy family oriented camping in a natural wooded setting. We offer lakefront and large wooded sites, along with motel rooms and fully furnished park models. Our amenities include an indoor pool and hot tub, game room, miniature golf, weekend hayrides, playgrounds, fishing and much more.<br /> 4495 South Spruce Avenue White Cloud, MI 49349","address":"4495 South Spruce Avenue, White Cloud, MI 49349","location":{"lat":"43.4733924","lng":"-85.7449529","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/adventure-bound-camping-resorts-west-michigan/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Enjoy family oriented camping in a natural wooded setting. We offer lakefront and large wooded sites, along with motel rooms and fully furnished park models. Our amenities include an indoor pool and hot tub, game room, miniature golf, weekend hayrides, playgrounds, fishing and much more.<br /> 4495 South Spruce Avenue White Cloud, MI 49349","post_content":"[mmi_map]\r\n\r\n<img class=\"alignright wp-image-25447\" src=\"http://www.michiganrvandcampgrounds.org/index.php?gf-download=2016%2F08%2FLogo.jpg&form-id=9&field-id=3&hash=d9fe9487c259f23cbb2ecd5e9bd31f0bd078b400eb709f142640eade4bf1af8c\" width=\"180\" /><h1>Adventure Bound Camping Resorts - West Michigan</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nEnjoy family oriented camping in a natural wooded setting. We offer lakefront and large wooded sites, along with motel rooms and fully furnished park models. Our amenities include an indoor pool and hot tub, game room, miniature golf, weekend hayrides, playgrounds, fishing and much more.\r\n\r\n4495 South Spruce Avenue\r\nWhite Cloud, MI 49349\r\n\r\n<strong>\r\n\r\nPhone: (231) 689-6685\r\nFax: (231) 689-0040\r\nWebsite: <a href=\"https://www.abcamping.com/westmichigan/\" target=\"_blank\" rel=\"noopener\">https://www.abcamping.com/westmichigan/</a>\r\nemail: <a href=\"mailto:ap@abcamping.com\">ap@abcamping.com</a>\r\n</strong>\r\n\r\n<a href=\"http://www.michiganrvandcampgrounds.org/index.php?gf-download=2016%2F08%2Fsite-map.jpg&form-id=9&field-id=4&hash=0c3c5a3d2c10b080debe79c2f29fb59b13c4de7444f08aab5c5553f101471a14 \" target=\"_blank\" rel=\"noopener noreferrer\"><img class=\"size-full wp-image-25829 alignright\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/04/sitemap-1.jpg\" alt=\"sitemap\" width=\"150\" height=\"180\" /></a><b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nLaundry Facilities\r\nFishing\r\nRecreation Facilities\r\nPlanned Activities\r\nCamp Store\r\nCable TV\r\nWiFi Available\r\nPet Friendly\r\nSells Propane Gas\r\nBoat Canoe Rentals\r\nPull-Through Sites\r\nTent Sites\r\nCabin Rentals\r\nHandicap Accessible\r\nOnline Reservations\r\n\r\n\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2021/04/Woods-and-Water-Feature-Image-scaled.jpg\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"http://www.michiganrvandcampgrounds.org/index.php?gf-download=2016%2F08%2FLake.JPG&form-id=9&field-id=6&hash=3c33b8e0c6900f4dcc6a0cd326bd3017392ffd6d36293b9586ead6bd28e0aea3\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"http://www.michiganrvandcampgrounds.org/index.php?gf-download=2016%2F08%2F1Pool.jpg&form-id=9&field-id=7&hash=eaa74a7ce234e8abf96c6744154c708e2cd1e1f2e0940b56dbdc46e50bcbcf3c\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"http://www.michiganrvandcampgrounds.org/index.php?gf-download=2016%2F08%2FLodge.JPG&form-id=9&field-id=8&hash=3fff155473c395bdddd76dc1edf893a8e8d3facff2abb521eb472eafb6baeba6\" />\r\n ","post_title":"Adventure Bound Camping Resorts &#8211; West Michigan","post_link":"https://www.michiganrvandcampgrounds.org/member-info/adventure-bound-camping-resorts-west-michigan/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Adventure Bound Camping Resorts &#8211; West Michigan\" width=\"300\" height=\"186\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2021/04/Woods-and-Water-Feature-Image-300x186.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"4495 South Spruce Avenue, White Cloud, MI 49349","errors":[],"address_formatted":"4495 S Spruce Ave, White Cloud, MI 49349, USA","lat":"43.4733924","lng":"-85.7449529","street_number":"4495","street_name_long":"South Spruce Avenue","street_name_short":"S Spruce Ave","city":"White Cloud","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49349"},"%_mmi_phone%":"(231) 689-6685","%_mmi_url%":"https://www.abcamping.com/westmichigan/","%_wpgmp_location_address%":"4495 South Spruce Avenue, White Cloud, MI 49349","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":"","%avada_post_views_count%":"2182","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-01-31","%_wpgmp_metabox_latitude%":"43.4733924","%_wpgmp_metabox_longitude%":"-85.7449529","%_thumbnail_id%":"73532","taxonomy=portfolio_category":"Boat Canoe Rentals, Cabin Rentals, Cable TV, Camp Store, Campgrounds, Fishing, Full Hook-Up, Handicap Accessible, Laundry Facilities, Northwest Michigan Region, Online Reservations, Pet Friendly, Planned Activities, Pull-Through Sites, Recreation Facilities, Sells Propane Gas, Swimming, Tent Sites, WiFi Available","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74292,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Sun Retreats Silver Lake","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/sun-retreats-silver-lake/\">Sun Retreats Silver Lake</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Located near beautiful Silver Lake Sand Dunes. Enjoy large sites, heated pools, hot tub, social room, modern bathrooms, grocery store, laundry, WiFi and more. Close by there is golf, go carts, boat rentals, cottage rentals, dune rides, hiking, biking and lighthouse views. Seasonal sites are also available. Paved road and big rigs. Discounts available. Top 10 Good Sam Park.<br /> 1441 North 34th Avenue Mears, MI 49436","address":"1441 North 34th Avenue, Mears, MI 49436","location":{"lat":"43.6720196","lng":"-86.4734714","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/sun-retreats-silver-lake/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Located near beautiful Silver Lake Sand Dunes. Enjoy large sites, heated pools, hot tub, social room, modern bathrooms, grocery store, laundry, WiFi and more. Close by there is golf, go carts, boat rentals, cottage rentals, dune rides, hiking, biking and lighthouse views. Seasonal sites are also available. Paved road and big rigs. Discounts available. Top 10 Good Sam Park.<br /> 1441 North 34th Avenue Mears, MI 49436","post_content":"[mmi_map]\r\n\r\n <h1>Sun Retreats Silver Lake</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nLocated near beautiful Silver Lake Sand Dunes. Enjoy large sites, heated pools, hot tub, social room, modern bathrooms, grocery store, laundry, WiFi and more. Close by there is golf, go carts, boat rentals, cottage rentals, dune rides, hiking, biking and lighthouse views. Seasonal sites are also available. Paved road and big rigs. Discounts available. Top 10 Good Sam Park.\r\n\r\n1441 North 34th Avenue\r\nMears, MI 49436\r\n\r\n<strong>\r\n\r\nPhone: (231) 873-9200\r\nFax: (231) 873-0522\r\nWebsite: <a href=\"http://www.silvercreekrv.com\" target=\"_blank\" rel=\"noopener\">www.silvercreekrv.com</a>\r\nemail: <a href=\"mailto:silvercreek@suncommunities.com\">silvercreek@suncommunities.com</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nLaundry Facilities\r\nRecreation Facilities\r\nPlanned Activities\r\nCamp Store\r\nCable TV\r\nWiFi Available\r\nPet Friendly\r\nSells Propane Gas\r\nPull-Through Sites\r\nCabin Rentals\r\nHandicap Accessible\r\nOnline Reservations\r\nCall For Information\r\n\r\n\r\n     ","post_title":"Sun Retreats Silver Lake","post_link":"https://www.michiganrvandcampgrounds.org/member-info/sun-retreats-silver-lake/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sun Retreats Silver Lake\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2020/08/c10-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"1441 North 34th Avenue, Mears, MI 49436","errors":[],"address_formatted":"1441 N 34th Ave, Mears, MI 49436, USA","lat":"43.6720196","lng":"-86.4734714","street_number":"1441","street_name_long":"North 34th Avenue","street_name_short":"N 34th Ave","city":"Mears","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49436"},"%_mmi_phone%":"(231) 873-9200","%_mmi_url%":"www.silvercreekrv.com","%_wpgmp_location_address%":"1441 North 34th Avenue, Mears, MI 49436","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":"","%avada_post_views_count%":"1766","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"25-04-2024","%_wp_old_date%":"2022-01-31","%_wpgmp_metabox_latitude%":"43.6720196","%_wpgmp_metabox_longitude%":"-86.4734714","%_wp_old_slug%":"silver-creek-rv-resort","%_thumbnail_id%":"72703","taxonomy=portfolio_category":"Cabin Rentals, Cable TV, Camp Store, Campgrounds, Full Hook-Up, Handicap Accessible, Laundry Facilities, Northwest Michigan Region, Online Reservations, Pet Friendly, Planned Activities, Pull-Through Sites, Recreation Facilities, Sells Propane Gas, Swimming, WiFi Available","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74267,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Pickerel Lakeside Campground and Cottages","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/pickerel-lakeside-campground-and-cottages/\">Pickerel Lakeside Campground and Cottages</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Quiet and family oridented lakefront campground and cottages are nestled on 40 acres. The Pere Marquette River (salmon, steelhead, trout) and golf course are a short drive away.<br /> 12666 N. Woodbridge Ave. Bitely, MI 49309","address":"12666 N. Woodbridge Ave., Bitely, MI 49309","location":{"lat":"43.783657","lng":"-85.846821","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/pickerel-lakeside-campground-and-cottages/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Quiet and family oridented lakefront campground and cottages are nestled on 40 acres. The Pere Marquette River (salmon, steelhead, trout) and golf course are a short drive away.<br /> 12666 N. Woodbridge Ave. Bitely, MI 49309","post_content":"[mmi_map]\r\n\r\n <h1>Pickerel Lakeside Campground and Cottages</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nQuiet and family oridented lakefront campground and cottages are nestled on 40 acres. The Pere Marquette River (salmon, steelhead, trout) and golf course are a short drive away.\r\n\r\n12666 N. Woodbridge Ave.\r\nBitely, MI 49309\r\n\r\n<strong>\r\n\r\nPhone: (231) 745-7268\r\n Website: <a href=\"http://www.lakecamp-cottages.com\" target=\"_blank\" rel=\"noopener\">www.lakecamp-cottages.com</a>\r\nemail: <a href=\"mailto:info@lakecamp-cottages.com\">info@lakecamp-cottages.com</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nSwimming\r\nFishing\r\nRecreation Facilities\r\nCable TV\r\nPet Friendly\r\nPull-Through Sites\r\nTent Sites\r\nCabin Rentals\r\nCall For Information\r\n\r\n\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"http://www.michiganrvandcampgrounds.org/wp-content/uploads/2018/09/featured.jpg\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2018/09/add-1.jpg\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2018/09/add-2.jpg\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2018/09/add-3.jpg\" />\r\n ","post_title":"Pickerel Lakeside Campground and Cottages","post_link":"https://www.michiganrvandcampgrounds.org/member-info/pickerel-lakeside-campground-and-cottages/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pickerel Lakeside Campground and Cottages\" width=\"300\" height=\"149\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2018/09/add-1-300x149.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"12666 N. Woodbridge Ave., Bitely, MI 49309","errors":[],"address_formatted":"12666 N Woodbridge Ave, Bitely, MI 49309, USA","lat":"43.783657","lng":"-85.846821","street_number":"12666","street_name_long":"North Woodbridge Avenue","street_name_short":"N Woodbridge Ave","city":"Bitely","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49309"},"%_mmi_phone%":"(231) 745-7268","%_mmi_url%":"www.lakecamp-cottages.com","%_wpgmp_location_address%":"12666 N. Woodbridge Ave., Bitely, MI 49309","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_wpgmp_metabox_latitude%":"43.783657","%_wpgmp_metabox_longitude%":"-85.846821","%_fusion%":"","%avada_post_views_count%":"770","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-10-12","%_edit_lock%":"1684786736:20","%_thumbnail_id%":"64339","taxonomy=portfolio_category":"Cabin Rentals, Cable TV, Campgrounds, Fishing, Northwest Michigan Region, Pet Friendly, Pull-Through Sites, Recreation Facilities, Swimming, Tent Sites","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74946,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"CranHill","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/cranhill/\">CranHill</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Just 10 min. east of Big Rapids, CranHill&#x2019;s Christian family campground is focused on building strong families, connecting people, and transforming lives. Located on 2 lakes (1 all-sports). Firewood available. We offer horseback riding, petting farm, target sports, a 40-foot climbing tower, ropes course, 18 hole disc golf, beach, giant slip-n-slide, boats,aqua park, & more. Water & Electric on all sites. Full week programming June - Aug. Online registration available!<br /> 14444 17 Mile Road Rodney, MI 49342","address":"14444 17 Mile Road, Rodney, MI 49342","location":{"lat":"43.7189385","lng":"-85.3730428","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/cranhill/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Just 10 min. east of Big Rapids, CranHill&#x2019;s Christian family campground is focused on building strong families, connecting people, and transforming lives. Located on 2 lakes (1 all-sports). Firewood available. We offer horseback riding, petting farm, target sports, a 40-foot climbing tower, ropes course, 18 hole disc golf, beach, giant slip-n-slide, boats,aqua park, & more. Water & Electric on all sites. Full week programming June - Aug. Online registration available!<br /> 14444 17 Mile Road Rodney, MI 49342","post_content":"[mmi_map]\r\n\r\n <h1>CranHill</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nJust 10 min. east of Big Rapids, CranHill&#x2019;s Christian family campground is focused on building strong families, connecting people, and transforming lives. Located on 2 lakes (1 all-sports). Firewood available. We offer horseback riding, petting farm, target sports, a 40-foot climbing tower, ropes course, 18 hole disc golf, beach, giant slip-n-slide, boats,aqua park, & more. Water & Electric on all sites. Full week programming June - Aug. Online registration available!\r\n\r\n14444 17 Mile Road\r\nRodney, MI 49342\r\n\r\n<strong>\r\n\r\nPhone: (231) 796-7669\r\nFax: (231) 796-4550\r\nWebsite: <a href=\"http://www.cranhillranch.com\" target=\"_blank\" rel=\"noopener\">www.cranhillranch.com</a>\r\nemail: <a href=\"mailto:info@cranhillranch.com\">info@cranhillranch.com</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nLaundry Facilities\r\nFishing\r\nRecreation Facilities\r\nPlanned Activities\r\nCamp Store\r\nWiFi Available\r\nPet Friendly\r\nSells Propane Gas\r\nBoat Canoe Rentals\r\nPull-Through Sites\r\nTent Sites\r\nYear-Round Camping\r\nCabin Rentals\r\nHandicap Accessible\r\nOnline Reservations\r\nCall For Information\r\n\r\n\r\n     ","post_title":"CranHill","post_link":"https://www.michiganrvandcampgrounds.org/member-info/cranhill/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"CranHill\" width=\"300\" height=\"199\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2022/01/c23-300x199.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"14444 17 Mile Road, Rodney, MI 49342","errors":[],"address_formatted":"14444 17 Mile Rd, Rodney, MI 49342, USA","lat":"43.7189385","lng":"-85.3730428","street_number":"14444","street_name_long":"17 Mile Road","street_name_short":"17 Mile Rd","city":"Rodney","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49342"},"%_mmi_phone%":"(231) 796-7669","%_mmi_url%":"www.cranhillranch.com","%_wpgmp_location_address%":"14444 17 Mile Road, Rodney, MI 49342","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":"","%avada_post_views_count%":"1284","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-01-31","%_wpgmp_metabox_latitude%":"43.7189385","%_wpgmp_metabox_longitude%":"-85.3730428","%_thumbnail_id%":"74211","taxonomy=portfolio_category":"Boat Canoe Rentals, Cabin Rentals, Camp Store, Campgrounds, Fishing, Full Hook-Up, Handicap Accessible, Laundry Facilities, Northwest Michigan Region, Online Reservations, Pet Friendly, Planned Activities, Pull-Through Sites, Recreation Facilities, Sells Propane Gas, Swimming, Tent Sites, WiFi Available, Year-Round Camping","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74249,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Leisure Time Campground","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/leisure-time-campground/\">Leisure Time Campground</a></div>\r\n</div>","content":"Northwest Michigan Region<br />We are located approximately 90 miles northwest of Grand Rapids, and 40 miles northeast of Ludington. We are nestled into the heart of Michigan's Manistee National Forest, where there are limitless opportunities for all types of outdoor recreation activities.\nWe welcome you to our quiet, family atmosphere park, where a clean, well kept park and a friendly atmosphere are our promise to you. The 6 1/2 acre park has 250 feet of waterfront on Seaman Lake where patrons can swim, boat or fish.<br /> 9214 West Five Mile Irons, MI 49644","address":"9214 West Five Mile, Irons, MI 49644","location":{"lat":"44.0601906","lng":"-85.9808922","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/leisure-time-campground/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />We are located approximately 90 miles northwest of Grand Rapids, and 40 miles northeast of Ludington. We are nestled into the heart of Michigan's Manistee National Forest, where there are limitless opportunities for all types of outdoor recreation activities.\nWe welcome you to our quiet, family atmosphere park, where a clean, well kept park and a friendly atmosphere are our promise to you. The 6 1/2 acre park has 250 feet of waterfront on Seaman Lake where patrons can swim, boat or fish.<br /> 9214 West Five Mile Irons, MI 49644","post_content":"[mmi_map]\r\n\r\n <h1>Leisure Time Campground</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nWe are located approximately 90 miles northwest of Grand Rapids, and 40 miles northeast of Ludington. We are nestled into the heart of Michigan's Manistee National Forest, where there are limitless opportunities for all types of outdoor recreation activities.\nWe welcome you to our quiet, family atmosphere park, where a clean, well kept park and a friendly atmosphere are our promise to you. The 6 1/2 acre park has 250 feet of waterfront on Seaman Lake where patrons can swim, boat or fish.\r\n\r\n9214 West Five Mile\r\nIrons, MI 49644\r\n\r\n<strong>\r\n\r\nPhone: (231) 464-6614\r\n Website: <a href=\"http://www.leisuretimecampground.com\" target=\"_blank\" rel=\"noopener\">www.leisuretimecampground.com</a>\r\nemail: <a href=\"mailto:leisuretimecampground@aol.com\">leisuretimecampground@aol.com</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nLaundry Facilities\r\nFishing\r\nPlanned Activities\r\nCamp Store\r\nCable TV\r\nWiFi Available\r\nPet Friendly\r\nSells Propane Gas\r\nBoat Canoe Rentals\r\nPull-Through Sites\r\nTent Sites\r\nCabin Rentals\r\nOnline Reservations\r\nCall For Information\r\n\r\n\r\n     ","post_title":"Leisure Time Campground","post_link":"https://www.michiganrvandcampgrounds.org/member-info/leisure-time-campground/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Leisure Time Campground\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2022/01/c5-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"9214 West Five Mile, Irons, MI 49644","errors":[],"address_formatted":"9214 W 5 Mile Rd, Irons, MI 49644, USA","lat":"44.0601906","lng":"-85.9808922","street_number":"9214","street_name_long":"West 5 Mile Road","street_name_short":"W 5 Mile Rd","city":"Irons","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49644"},"%_mmi_phone%":"(231) 464-6614","%_mmi_url%":"www.leisuretimecampground.com","%_wpgmp_location_address%":"9214 West Five Mile, Irons, MI 49644","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":"","%avada_post_views_count%":"1101","%avada_today_post_views_count%":"3","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-01-31","%_wpgmp_metabox_latitude%":"44.0601906","%_wpgmp_metabox_longitude%":"-85.9808922","%_thumbnail_id%":"74254","taxonomy=portfolio_category":"Boat Canoe Rentals, Cabin Rentals, Cable TV, Camp Store, Campgrounds, Fishing, Full Hook-Up, Laundry Facilities, Northwest Michigan Region, Online Reservations, Pet Friendly, Planned Activities, Pull-Through Sites, Sells Propane Gas, Swimming, Tent Sites, WiFi Available","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74253,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Traverse City KOA","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/traverse-city-koa/\">Traverse City KOA</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Large grassy and shady sites, sparkling clean restrooms, deluxe cabins, camping cabins, giant chess, mini-golf, playground, basketball, game room and activities. Free WiFi. Heated pool, jumping pillow, gem mining station, remote control car track, fun train rides and Kamp K9. Conveniently located near Traverse City attractions. Main roads paved. Wood is available at the campground.<br /> 9700 M-37 Buckley, MI 49620","address":"9700 M-37, Buckley, MI 49620","location":{"lat":"44.5459421","lng":"-85.6784784","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/traverse-city-koa/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Large grassy and shady sites, sparkling clean restrooms, deluxe cabins, camping cabins, giant chess, mini-golf, playground, basketball, game room and activities. Free WiFi. Heated pool, jumping pillow, gem mining station, remote control car track, fun train rides and Kamp K9. Conveniently located near Traverse City attractions. Main roads paved. Wood is available at the campground.<br /> 9700 M-37 Buckley, MI 49620","post_content":"[mmi_map]\r\n\r\n <h1>Traverse City KOA</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nLarge grassy and shady sites, sparkling clean restrooms, deluxe cabins, camping cabins, giant chess, mini-golf, playground, basketball, game room and activities. Free WiFi. Heated pool, jumping pillow, gem mining station, remote control car track, fun train rides and Kamp K9. Conveniently located near Traverse City attractions. Main roads paved. Wood is available at the campground.\r\n\r\n9700 M-37\r\nBuckley, MI 49620\r\n\r\n<strong>\r\n\r\nPhone: (231) 269-3203\r\nFax: (231) 269-4478\r\nWebsite: <a href=\"http://koa.com/campgrounds/traverse-city/\" target=\"_blank\" rel=\"noopener\">http://koa.com/campgrounds/traverse-city/</a>\r\nemail: <a href=\"mailto:info@traversecitykoa.com\">info@traversecitykoa.com</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nLaundry Facilities\r\nRecreation Facilities\r\nPlanned Activities\r\nCamp Store\r\nCable TV\r\nWiFi Available\r\nPet Friendly\r\nSells Propane Gas\r\nPull-Through Sites\r\nTent Sites\r\nCabin Rentals\r\nOnline Reservations\r\nCall For Information\r\n\r\n\r\n     ","post_title":"Traverse City KOA","post_link":"https://www.michiganrvandcampgrounds.org/member-info/traverse-city-koa/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Traverse City KOA\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2022/07/c3-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"9700 M-37, Buckley, MI 49620","errors":[],"address_formatted":"9700 M-37, Buckley, MI 49620, USA","lat":"44.5459421","lng":"-85.6784784","street_number":"9700","street_name_long":"Michigan 37","street_name_short":"M-37","city":"Buckley","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49620"},"%_mmi_phone%":"(231) 269-3203","%_mmi_url%":"http://koa.com/campgrounds/traverse-city/","%_wpgmp_location_address%":"9700 M-37, Buckley, MI 49620","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":"","%avada_post_views_count%":"1137","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-01-31","%_wpgmp_metabox_latitude%":"44.5459421","%_wpgmp_metabox_longitude%":"-85.6784784","%_thumbnail_id%":"74877","taxonomy=portfolio_category":"Cabin Rentals, Cable TV, Camp Store, Campgrounds, Full Hook-Up, Laundry Facilities, Northwest Michigan Region, Online Reservations, Pet Friendly, Planned Activities, Pull-Through Sites, Recreation Facilities, Sells Propane Gas, Swimming, Tent Sites, WiFi Available","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74260,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Lake Billings RV Park &#038; Campground","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/lake-billings-rv-park-campground/\">Lake Billings RV Park &#038; Campground</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Lake, 37 full hook-ups, 48 electric and water, clean restrooms, hot showers, dump station, firewood, pavilions, playgounds and more. Daily, weekly and monthly rates available. Open April 15 to October 15. Office hours-10 am to 6 pm.<br /> 221 East Elmore St. Manton, MI 49663","address":"221 East Elmore St., Manton, MI 49663","location":{"lat":"44.4119898","lng":"-85.3951074","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/lake-billings-rv-park-campground/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Lake, 37 full hook-ups, 48 electric and water, clean restrooms, hot showers, dump station, firewood, pavilions, playgounds and more. Daily, weekly and monthly rates available. Open April 15 to October 15. Office hours-10 am to 6 pm.<br /> 221 East Elmore St. Manton, MI 49663","post_content":"[mmi_map]\r\n\r\n <h1>Lake Billings RV Park & Campground</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nLake, 37 full hook-ups, 48 electric and water, clean restrooms, hot showers, dump station, firewood, pavilions, playgounds and more. Daily, weekly and monthly rates available. Open April 15 to October 15. Office hours-10 am to 6 pm.\r\n\r\n221 East Elmore St.\r\nManton, MI 49663\r\n\r\n<strong>\r\n\r\nPhone: (231) 824-6454\r\n  email: <a href=\"mailto:lakebillingscampground@mantonmichigan.us\">lakebillingscampground@mantonmichigan.us</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nLaundry Facilities\r\nFishing\r\nRecreation Facilities\r\nPlanned Activities\r\nWiFi Available\r\nPet Friendly\r\nTent Sites\r\nHandicap Accessible\r\nCall For Information\r\n\r\n\r\n     ","post_title":"Lake Billings RV Park &#038; Campground","post_link":"https://www.michiganrvandcampgrounds.org/member-info/lake-billings-rv-park-campground/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lake Billings RV Park &#038; Campground\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2022/01/c1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"221 East Elmore St., Manton, MI 49663","errors":[],"address_formatted":"221 E Elmore St, Manton, MI 49663, USA","lat":"44.4119898","lng":"-85.3951074","street_number":"221","street_name_long":"East Elmore Street","street_name_short":"E Elmore St","city":"Manton","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49663"},"%_mmi_phone%":"(231) 824-6454","%_mmi_url%":"","%_wpgmp_location_address%":"221 East Elmore St., Manton, MI 49663","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":"","%avada_post_views_count%":"2112","%avada_today_post_views_count%":"4","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-01-31","%_wpgmp_metabox_latitude%":"44.4119898","%_wpgmp_metabox_longitude%":"-85.3951074","%_thumbnail_id%":"74207","taxonomy=portfolio_category":"Campgrounds, Fishing, Full Hook-Up, Handicap Accessible, Laundry Facilities, Northwest Michigan Region, Pet Friendly, Planned Activities, Recreation Facilities, Swimming, Tent Sites, WiFi Available","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74261,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Holiday Park Campground","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/holiday-park-campground/\">Holiday Park Campground</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Traverse City's premier destination for RV camping. Situated along the south shore of Silver Lake in Traverse City, Michigan, Holiday RV Park & Campground is one of Michigan's true gems.<br /> 4860 US 31 South Traverse City, MI 49684","address":"4860 US 31 South, Traverse City, MI 49684","location":{"lat":"44.7349478","lng":"-85.6460944","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/holiday-park-campground/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Traverse City's premier destination for RV camping. Situated along the south shore of Silver Lake in Traverse City, Michigan, Holiday RV Park & Campground is one of Michigan's true gems.<br /> 4860 US 31 South Traverse City, MI 49684","post_content":"[mmi_map]\r\n\r\n <h1>Holiday Park Campground</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nTraverse City's premier destination for RV camping. Situated along the south shore of Silver Lake in Traverse City, Michigan, Holiday RV Park & Campground is one of Michigan's true gems.\r\n\r\n4860 US 31 South\r\nTraverse City, MI 49684\r\n\r\n<strong>\r\n\r\nPhone: (231) 943-4410\r\n Website: <a href=\"http://www.holidayparktc.com\" target=\"_blank\" rel=\"noopener\">www.holidayparktc.com</a>\r\nemail: <a href=\"mailto:dennis@holidayparktc.com\">dennis@holidayparktc.com</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\n\r\n\r\n     ","post_title":"Holiday Park Campground","post_link":"https://www.michiganrvandcampgrounds.org/member-info/holiday-park-campground/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Holiday Park Campground\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2022/01/c15-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"4860 US 31 South, Traverse City, MI 49684","errors":[],"address_formatted":"4860 N U.S. 31 S, Traverse City, MI 49684, USA","lat":"44.7349478","lng":"-85.6460944","street_number":"4860","street_name_long":"N U.S. 31 S","street_name_short":"N U.S. 31 S","city":"Traverse City","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49684"},"%_mmi_phone%":"(231) 943-4410","%_mmi_url%":"www.holidayparktc.com","%_wpgmp_location_address%":"4860 US 31 South, Traverse City, MI 49684","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":"","%avada_post_views_count%":"1181","%avada_today_post_views_count%":"5","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-01-31","%_wpgmp_metabox_latitude%":"44.7349478","%_wpgmp_metabox_longitude%":"-85.6460944","%_thumbnail_id%":"74243","taxonomy=portfolio_category":"Campgrounds, Northwest Michigan Region","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74237,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Jellystone Park Petoskey","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/jellystone-park-petoskey/\">Jellystone Park Petoskey</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Spend some time in Northwest Michigan at one of the highest rated RV parks in N. America. Enjoy 30 acres of beautiful landscaping and shade trees. Amenities include swimming pool and hot-tub, snack bar, horseshoes, volleyball and a dog park. In the heart of Petoskey, just minutes away from Lake Michigan.<br /> 1800 North US 31 Petoskey, MI 49770","address":"1800 North US 31, Petoskey, MI 49770","location":{"lat":"45.3950953","lng":"-84.8940051","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/jellystone-park-petoskey/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Spend some time in Northwest Michigan at one of the highest rated RV parks in N. America. Enjoy 30 acres of beautiful landscaping and shade trees. Amenities include swimming pool and hot-tub, snack bar, horseshoes, volleyball and a dog park. In the heart of Petoskey, just minutes away from Lake Michigan.<br /> 1800 North US 31 Petoskey, MI 49770","post_content":"[mmi_map]\r\n\r\n <h1>Jellystone Park Petoskey</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nSpend some time in Northwest Michigan at one of the highest rated RV parks in N. America. Enjoy 30 acres of beautiful landscaping and shade trees. Amenities include swimming pool and hot-tub, snack bar, horseshoes, volleyball and a dog park. In the heart of Petoskey, just minutes away from Lake Michigan.\r\n\r\n1800 North US 31\r\nPetoskey, MI 49770\r\n\r\n<strong>\r\n\r\nPhone: (231) 347-0005\r\nFax: (231) 347-6999\r\nWebsite: <a href=\"http://www.petoskeykoa.com\" target=\"_blank\" rel=\"noopener\">www.petoskeykoa.com</a>\r\nemail: <a href=\"mailto:petoskeykoa@suncommunities.com\">petoskeykoa@suncommunities.com</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nLaundry Facilities\r\nFishing\r\nRecreation Facilities\r\nPlanned Activities\r\nCamp Store\r\nCable TV\r\nWiFi Available\r\nPet Friendly\r\nSells Propane Gas\r\nPull-Through Sites\r\nTent Sites\r\nCabin Rentals\r\nHandicap Accessible\r\nOnline Reservations\r\nCall For Information\r\n\r\n\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2021/04/petoskey-koa-rv-sites-14_PetoskeyKOA_featured.jpg\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2019/10/petoskey-koa-gaga-ball-2_PetoskeyKOA_additional1.jpg\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2019/10/petoskey-koa-main-park-image_PetoskeyKOA_additional2.jpg\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2019/10/petoskey-koa-overview-4_PetoskeyKOA_additional3.jpg\" />\r\n ","post_title":"Jellystone Park Petoskey","post_link":"https://www.michiganrvandcampgrounds.org/member-info/jellystone-park-petoskey/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Jellystone Park Petoskey\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2021/04/petoskey-koa-rv-sites-14_PetoskeyKOA_featured-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"1800 North US 31, Petoskey, MI 49770","errors":[],"address_formatted":"1800 US-31, Petoskey, MI 49770, USA","lat":"45.3950953","lng":"-84.8940051","street_number":"1800","street_name_long":"U.S. 31","street_name_short":"US-31","city":"Petoskey","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49770"},"%_mmi_phone%":"(231) 347-0005","%_mmi_url%":"www.petoskeykoa.com","%_wpgmp_location_address%":"1800 North US 31, Petoskey, MI 49770","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":"","%avada_post_views_count%":"2440","%avada_today_post_views_count%":"4","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-01-31","%_wpgmp_metabox_latitude%":"45.3950953","%_wpgmp_metabox_longitude%":"-84.8940051","%_wp_old_slug%":"petoskey-koa-campground","%_thumbnail_id%":"73489","taxonomy=portfolio_category":"Cabin Rentals, Cable TV, Camp Store, Campgrounds, Fishing, Full Hook-Up, Handicap Accessible, Laundry Facilities, Northwest Michigan Region, Online Reservations, Pet Friendly, Planned Activities, Pull-Through Sites, Recreation Facilities, Sells Propane Gas, Swimming, Tent Sites, WiFi Available","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74245,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Vacation Station RV Resort","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/vacation-station-rv-resort/\">Vacation Station RV Resort</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Located 3 miles from beautiful Lake Michigan beaches. Concrete slabs, paved roads, heated pool, hot tub, clubhouse, grocery store, propane refill, laundry, WiFi, planned activities, on-off services. Big rigs, seasonal/transient sites. Golf Cart rentals. Walk to restaurants, shopping. Top 10 Good Sam Park. 1-800-499-1060. Campstore and wood available.<br /> 4895 West US 10 Ludington, MI 49431","address":"4895 West US 10, Ludington, MI 49431","location":{"lat":"43.955373","lng":"-86.4011447","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/vacation-station-rv-resort/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Located 3 miles from beautiful Lake Michigan beaches. Concrete slabs, paved roads, heated pool, hot tub, clubhouse, grocery store, propane refill, laundry, WiFi, planned activities, on-off services. Big rigs, seasonal/transient sites. Golf Cart rentals. Walk to restaurants, shopping. Top 10 Good Sam Park. 1-800-499-1060. Campstore and wood available.<br /> 4895 West US 10 Ludington, MI 49431","post_content":"[mmi_map]\r\n\r\n <h1>Vacation Station RV Resort</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nLocated 3 miles from beautiful Lake Michigan beaches. Concrete slabs, paved roads, heated pool, hot tub, clubhouse, grocery store, propane refill, laundry, WiFi, planned activities, on-off services. Big rigs, seasonal/transient sites. Golf Cart rentals. Walk to restaurants, shopping. Top 10 Good Sam Park. 1-800-499-1060. Campstore and wood available.\r\n\r\n4895 West US 10\r\nLudington, MI 49431\r\n\r\n<strong>\r\n\r\nPhone: 231-845-1100\r\nFax: (231) 843-0500\r\nWebsite: <a href=\"http://www.vacationstationrvresort.com\" target=\"_blank\" rel=\"noopener\">www.vacationstationrvresort.com</a>\r\nemail: <a href=\"mailto:info@vacationstationrvresort.com\">info@vacationstationrvresort.com</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nLaundry Facilities\r\nFishing\r\nRecreation Facilities\r\nPlanned Activities\r\nCamp Store\r\nCable TV\r\nWiFi Available\r\nPet Friendly\r\nSells Propane Gas\r\nPull-Through Sites\r\nCabin Rentals\r\nHandicap Accessible\r\nOnline Reservations\r\nCall For Information\r\n\r\n\r\n     ","post_title":"Vacation Station RV Resort","post_link":"https://www.michiganrvandcampgrounds.org/member-info/vacation-station-rv-resort/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Vacation Station RV Resort\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2017/05/c6-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"4895 West US 10, Ludington, MI 49431","errors":[],"address_formatted":"4895 US-10, Ludington, MI 49431, USA","lat":"43.955373","lng":"-86.4011447","street_number":"4895","street_name_long":"U.S. 10","street_name_short":"US-10","city":"Ludington","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49431"},"%_mmi_phone%":"231-845-1100","%_mmi_url%":"www.vacationstationrvresort.com","%_wpgmp_location_address%":"4895 West US 10, Ludington, MI 49431","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":"","%avada_post_views_count%":"1282","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-01-31","%_wpgmp_metabox_latitude%":"43.955373","%_wpgmp_metabox_longitude%":"-86.4011447","%_thumbnail_id%":"46155","taxonomy=portfolio_category":"Cabin Rentals, Cable TV, Camp Store, Campgrounds, Fishing, Full Hook-Up, Handicap Accessible, Laundry Facilities, Northwest Michigan Region, Online Reservations, Pet Friendly, Planned Activities, Pull-Through Sites, Recreation Facilities, Sells Propane Gas, Swimming, WiFi Available","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74247,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Holiday Camping Resort LLC","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/holiday-camping-resort-llc/\">Holiday Camping Resort LLC</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Quiet Family Campground located in picturesque Oceana County, away from the hustle and bustle of the tourist areas, but close enough to enjoy them. Near Silver Lake Sand Dunes, Michigan's Adventure, Hart-Montague Bike Trail, Lake Michigan and many golf courses. Full hook-ups are available, tenters are welcome.<br /> 5483 West Stony Lake Road New Era, MI 49446","address":"5483 West Stony Lake Road, New Era, MI 49446","location":{"lat":"43.5568642","lng":"-86.4143015","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/holiday-camping-resort-llc/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Quiet Family Campground located in picturesque Oceana County, away from the hustle and bustle of the tourist areas, but close enough to enjoy them. Near Silver Lake Sand Dunes, Michigan's Adventure, Hart-Montague Bike Trail, Lake Michigan and many golf courses. Full hook-ups are available, tenters are welcome.<br /> 5483 West Stony Lake Road New Era, MI 49446","post_content":"[mmi_map]\r\n\r\n<img class=\"alignright wp-image-25447\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2019/07/Holiday-rv-resort-logo.jpg\" width=\"180\" /><h1>Holiday Camping Resort LLC</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nQuiet Family Campground located in picturesque Oceana County, away from the hustle and bustle of the tourist areas, but close enough to enjoy them. Near Silver Lake Sand Dunes, Michigan's Adventure, Hart-Montague Bike Trail, Lake Michigan and many golf courses. Full hook-ups are available, tenters are welcome.\r\n\r\n5483 West Stony Lake Road\r\nNew Era, MI 49446\r\n\r\n<strong>\r\n\r\nPhone: (231) 861-5220\r\n Website: <a href=\"http://www.holidaycamping.com\" target=\"_blank\" rel=\"noopener\">www.holidaycamping.com</a>\r\nemail: <a href=\"mailto:camping@holidaycamping.com\">camping@holidaycamping.com</a>\r\n</strong>\r\n\r\n<a href=\"http://www.michiganrvandcampgrounds.org/index.php?gf-download=2016%2F08%2FCampGround-Map-and-Rules-PROOF.pdf&form-id=9&field-id=4&hash=4e006b3f953839ed36c8989bbda3f370dad2578034f26d26284a30cd33d03ab5 \" target=\"_blank\" rel=\"noopener noreferrer\"><img class=\"size-full wp-image-25829 alignright\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/04/sitemap-1.jpg\" alt=\"sitemap\" width=\"150\" height=\"180\" /></a><b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nLaundry Facilities\r\nRecreation Facilities\r\nPlanned Activities\r\nCamp Store\r\nWiFi Available\r\nPet Friendly\r\nSells Propane Gas\r\nPull-Through Sites\r\nTent Sites\r\nCabin Rentals\r\nOnline Reservations\r\nCall For Information\r\n\r\n\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2021/04/Holiday-Camping-Resort-Feature-Image.jpg\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2019/07/Holiday-rv-campground-pic.jpg\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2019/07/Holiday-rv-campground-chillaxin.jpg\" />\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2019/07/Holiday-rv-campground-night-swim.jpg\" />\r\n ","post_title":"Holiday Camping Resort LLC","post_link":"https://www.michiganrvandcampgrounds.org/member-info/holiday-camping-resort-llc/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Holiday Camping Resort LLC\" width=\"300\" height=\"225\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2021/04/Holiday-Camping-Resort-Feature-Image-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"5483 West Stony Lake Road, New Era, MI 49446","errors":[],"address_formatted":"5483 W Stony Lake Rd, New Era, MI 49446, USA","lat":"43.5568642","lng":"-86.4143015","street_number":"5483","street_name_long":"West Stony Lake Road","street_name_short":"W Stony Lake Rd","city":"New Era","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49446"},"%_mmi_phone%":"(231) 861-5220","%_mmi_url%":"www.holidaycamping.com","%_wpgmp_location_address%":"5483 West Stony Lake Road, New Era, MI 49446","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":"","%avada_post_views_count%":"1810","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-01-31","%_wpgmp_metabox_latitude%":"43.5568642","%_wpgmp_metabox_longitude%":"-86.4143015","%_thumbnail_id%":"73485","taxonomy=portfolio_category":"Cabin Rentals, Camp Store, Campgrounds, Full Hook-Up, Laundry Facilities, Northwest Michigan Region, Online Reservations, Pet Friendly, Planned Activities, Pull-Through Sites, Recreation Facilities, Sells Propane Gas, Swimming, Tent Sites, WiFi Available","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74231,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Hess Lake RV &#038; Mobile Home Park","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/hess-lake-rv-mobile-home-park/\">Hess Lake RV &#038; Mobile Home Park</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Open April 1st to Oct. 31st. Rates start at $1475.00 per season. Dock available/boat slips on Hess Lake starting at $499 a season. And, store your RV for the winter for an extra $75.00.<br /> 825 East 88th Street Newaygo, MI 49337","address":"825 East 88th Street, Newaygo, MI 49337","location":{"lat":"43.3954567","lng":"-85.7810606","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/hess-lake-rv-mobile-home-park/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Open April 1st to Oct. 31st. Rates start at $1475.00 per season. Dock available/boat slips on Hess Lake starting at $499 a season. And, store your RV for the winter for an extra $75.00.<br /> 825 East 88th Street Newaygo, MI 49337","post_content":"[mmi_map]\r\n\r\n <h1>Hess Lake RV & Mobile Home Park</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nOpen April 1st to Oct. 31st. Rates start at $1475.00 per season. Dock available/boat slips on Hess Lake starting at $499 a season. And, store your RV for the winter for an extra $75.00.\r\n\r\n825 East 88th Street\r\nNewaygo, MI 49337\r\n\r\n<strong>\r\n\r\nPhone: (231) 675-8896\r\nFax: (231) 452-6547\r\nWebsite: <a href=\"http://www.hesslakervandmhp.com\" target=\"_blank\" rel=\"noopener\">www.hesslakervandmhp.com</a>\r\nemail: <a href=\"mailto:sprecksellj@gmail.com\">sprecksellj@gmail.com</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nLaundry Facilities\r\nFishing\r\nCable TV\r\nPet Friendly\r\nMembers Only\r\nOnline Reservations\r\n\r\n\r\n     ","post_title":"Hess Lake RV &#038; Mobile Home Park","post_link":"https://www.michiganrvandcampgrounds.org/member-info/hess-lake-rv-mobile-home-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hess Lake RV &#038; Mobile Home Park\" width=\"300\" height=\"199\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2022/08/c22-300x199.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"825 East 88th Street, Newaygo, MI 49337","errors":[],"address_formatted":"825 E 88th St, Newaygo, MI 49337, USA","lat":"43.3954567","lng":"-85.7810606","street_number":"825","street_name_long":"East 88th Street","street_name_short":"E 88th St","city":"Newaygo","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49337"},"%_mmi_phone%":"(231) 675-8896","%_mmi_url%":"www.hesslakervandmhp.com","%_wpgmp_location_address%":"825 East 88th Street, Newaygo, MI 49337","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":"","%avada_post_views_count%":"2817","%avada_today_post_views_count%":"5","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-01-31","%_wpgmp_metabox_latitude%":"43.3954567","%_wpgmp_metabox_longitude%":"-85.7810606","%_thumbnail_id%":"74879","taxonomy=portfolio_category":"Cable TV, Campgrounds, Fishing, Full Hook-Up, Laundry Facilities, Members Only, Northwest Michigan Region, Online Reservations, Pet Friendly, Swimming","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74225,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Pat&#8217;s RV Park","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/pats-rv-park/\">Pat&#8217;s RV Park</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Camping on the backwaters of the Hodenpyle Dam with everything from tent sites to full hook up sites right on the water. Family friendly camping including cabins and pontoon boat rentals. The lake is great for fishing, kayaking, canoeing, swimming, and so much more! We have over 7 miles of hiking trails nearby, we are open late for hunting seasons, and are close to ATV trails!<br /> 2944 N Pat's Place Mesick, MI 49668","address":"2944 N Pat's Place, Mesick, MI 49668","location":{"lat":"44.3803598","lng":"-85.7650708","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/pats-rv-park/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Camping on the backwaters of the Hodenpyle Dam with everything from tent sites to full hook up sites right on the water. Family friendly camping including cabins and pontoon boat rentals. The lake is great for fishing, kayaking, canoeing, swimming, and so much more! We have over 7 miles of hiking trails nearby, we are open late for hunting seasons, and are close to ATV trails!<br /> 2944 N Pat's Place Mesick, MI 49668","post_content":"[mmi_map]\r\n\r\n <h1>Pat's RV Park</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nCamping on the backwaters of the Hodenpyle Dam with everything from tent sites to full hook up sites right on the water. Family friendly camping including cabins and pontoon boat rentals. The lake is great for fishing, kayaking, canoeing, swimming, and so much more! We have over 7 miles of hiking trails nearby, we are open late for hunting seasons, and are close to ATV trails!\r\n\r\n2944 N Pat's Place\r\nMesick, MI 49668\r\n\r\n<strong>\r\n\r\nPhone: (231) 885-2020\r\n Website: <a href=\"http://www.patsrvparkllc.com\" target=\"_blank\" rel=\"noopener\">www.patsrvparkllc.com</a>\r\nemail: <a href=\"mailto:patsrvparkllc@gmail.com\">patsrvparkllc@gmail.com</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nFull Hook-Up\r\nLaundry Facilities\r\nFishing\r\nPlanned Activities\r\nCamp Store\r\nPet Friendly\r\nBoat Canoe Rentals\r\nTent Sites\r\nCabin Rentals\r\nCall For Information\r\n\r\n\r\n     ","post_title":"Pat&#8217;s RV Park","post_link":"https://www.michiganrvandcampgrounds.org/member-info/pats-rv-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pat&#8217;s RV Park\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2022/01/c27-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"2944 N Pat's Place, Mesick, MI 49668","errors":[],"address_formatted":"S Pat's Pl, Springville Township, MI 49668, USA","lat":"44.3803598","lng":"-85.7650708","street_name_long":"South Pat's Place","street_name_short":"S Pat's Pl","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49668"},"%_mmi_phone%":"(231) 885-2020","%_mmi_url%":"www.patsrvparkllc.com","%_wpgmp_location_address%":"2944 N Pat's Place, Mesick, MI 49668","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":"","%avada_post_views_count%":"1560","%avada_today_post_views_count%":"3","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-01-31","%_wpgmp_metabox_latitude%":"44.3803598","%_wpgmp_metabox_longitude%":"-85.7650708","%_thumbnail_id%":"74217","taxonomy=portfolio_category":"Boat Canoe Rentals, Cabin Rentals, Camp Store, Campgrounds, Fishing, Full Hook-Up, Laundry Facilities, Northwest Michigan Region, Pet Friendly, Planned Activities, Tent Sites","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74206,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Vacation Trailer Park, Inc.","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/vacation-trailer-park-inc/\">Vacation Trailer Park, Inc.</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Call  (800) 482-5101 for reservations. We have daily, weekly and seasonal occupancy available year round. Located on the scenic Betsie River, 1 1/2 miles north of  Junction M-115 east and US 31 or 2 miles south of junction US 31 and M-115 west.<br /> 2080 Benzie Highway Benzonia, MI 49616","address":"2080 Benzie Highway, Benzonia, MI 49616","location":{"lat":"44.6022334","lng":"-86.1004171","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/vacation-trailer-park-inc/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Call  (800) 482-5101 for reservations. We have daily, weekly and seasonal occupancy available year round. Located on the scenic Betsie River, 1 1/2 miles north of  Junction M-115 east and US 31 or 2 miles south of junction US 31 and M-115 west.<br /> 2080 Benzie Highway Benzonia, MI 49616","post_content":"[mmi_map]\r\n\r\n <h1>Vacation Trailer Park, Inc.</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nCall  (800) 482-5101 for reservations. We have daily, weekly and seasonal occupancy available year round. Located on the scenic Betsie River, 1 1/2 miles north of  Junction M-115 east and US 31 or 2 miles south of junction US 31 and M-115 west.\r\n\r\n2080 Benzie Highway\r\nBenzonia, MI 49616\r\n\r\n<strong>\r\n\r\nPhone: (313) 348-1997\r\n Website: <a href=\"http://www.vacationtrailer.com\" target=\"_blank\" rel=\"noopener\">www.vacationtrailer.com</a>\r\n </strong>\r\n\r\n <b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nLaundry Facilities\r\nFishing\r\nRecreation Facilities\r\nPlanned Activities\r\nCamp Store\r\nCable TV\r\nWiFi Available\r\nPet Friendly\r\nBoat Canoe Rentals\r\nPull-Through Sites\r\nTent Sites\r\nYear-Round Camping\r\nCabin Rentals\r\nHandicap Accessible\r\nOnline Reservations\r\nCall For Information\r\n\r\n\r\n     ","post_title":"Vacation Trailer Park, Inc.","post_link":"https://www.michiganrvandcampgrounds.org/member-info/vacation-trailer-park-inc/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Vacation Trailer Park, Inc.\" width=\"300\" height=\"210\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/05/c11-300x210.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"2080 Benzie Highway, Benzonia, MI 49616","errors":[],"address_formatted":"2080 Benzie Hwy, Benzonia, MI 49616, USA","lat":"44.6022334","lng":"-86.1004171","street_number":"2080","street_name_long":"Benzie Highway","street_name_short":"Benzie Hwy","city":"Benzonia","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49616"},"%_mmi_phone%":"(313) 348-1997","%_mmi_url%":"www.vacationtrailer.com","%_wpgmp_location_address%":"2080 Benzie Highway, Benzonia, MI 49616","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":"","%avada_post_views_count%":"1456","%avada_today_post_views_count%":"6","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-01-31","%_wpgmp_metabox_latitude%":"44.6022334","%_wpgmp_metabox_longitude%":"-86.1004171","%_thumbnail_id%":"29920","taxonomy=portfolio_category":"Boat Canoe Rentals, Cabin Rentals, Cable TV, Camp Store, Campgrounds, Fishing, Full Hook-Up, Handicap Accessible, Laundry Facilities, Northwest Michigan Region, Online Reservations, Pet Friendly, Planned Activities, Pull-Through Sites, Recreation Facilities, Swimming, Tent Sites, WiFi Available, Year-Round Camping","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74208,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Timber Ridge RV &#038; Recreation Resort","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/timber-ridge-rv-recreation-resort/\">Timber Ridge RV &#038; Recreation Resort</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Minutes from downtown Traverse City. Large, shaded sites. Family oriented park featuring theme weekends and group activities. Swimming pool, horseshoes, dodge ball, playground, bike terrain park, basketball and volleyball courts. Miles of trails for hiking, biking, cross country skiing, snowshoeing, fat biking. Banquet/meeting facility available. WiFi. RV storage. 260 sites, 190 w/sewer. 30/50 amps, plus 40 cabins, cottages, park homes, yurts. Big Rig friendly.<br /> 4050 Hammond Road East Traverse City, MI 49686","address":"4050 Hammond Road East, Traverse City, MI 49686","location":{"lat":"44.7142423","lng":"-85.494468","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/timber-ridge-rv-recreation-resort/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Minutes from downtown Traverse City. Large, shaded sites. Family oriented park featuring theme weekends and group activities. Swimming pool, horseshoes, dodge ball, playground, bike terrain park, basketball and volleyball courts. Miles of trails for hiking, biking, cross country skiing, snowshoeing, fat biking. Banquet/meeting facility available. WiFi. RV storage. 260 sites, 190 w/sewer. 30/50 amps, plus 40 cabins, cottages, park homes, yurts. Big Rig friendly.<br /> 4050 Hammond Road East Traverse City, MI 49686","post_content":"[mmi_map]\r\n\r\n <h1>Timber Ridge RV & Recreation Resort</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nMinutes from downtown Traverse City. Large, shaded sites. Family oriented park featuring theme weekends and group activities. Swimming pool, horseshoes, dodge ball, playground, bike terrain park, basketball and volleyball courts. Miles of trails for hiking, biking, cross country skiing, snowshoeing, fat biking. Banquet/meeting facility available. WiFi. RV storage. 260 sites, 190 w/sewer. 30/50 amps, plus 40 cabins, cottages, park homes, yurts. Big Rig friendly.\r\n\r\n4050 Hammond Road East\r\nTraverse City, MI 49686\r\n\r\n<strong>\r\n\r\nPhone: (231) 947-2770\r\nFax: (231) 947-2771\r\nWebsite: <a href=\"http://www.timberridgeresort.net\" target=\"_blank\" rel=\"noopener\">www.timberridgeresort.net</a>\r\nemail: <a href=\"mailto:meranda@timberridgeresort.net\">meranda@timberridgeresort.net</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nLaundry Facilities\r\nRecreation Facilities\r\nPlanned Activities\r\nCamp Store\r\nCable TV\r\nWiFi Available\r\nPet Friendly\r\nSells Propane Gas\r\nPull-Through Sites\r\nTent Sites\r\nYear-Round Camping\r\nCabin Rentals\r\nOnline Reservations\r\nCall For Information\r\n\r\n\r\n     ","post_title":"Timber Ridge RV &#038; Recreation Resort","post_link":"https://www.michiganrvandcampgrounds.org/member-info/timber-ridge-rv-recreation-resort/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Timber Ridge RV &#038; Recreation Resort\" width=\"300\" height=\"198\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2022/01/c16-300x198.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"4050 Hammond Road East, Traverse City, MI 49686","errors":[],"address_formatted":"4050 E Hammond Rd, Traverse City, MI 49686, USA","lat":"44.7142423","lng":"-85.494468","street_number":"4050","street_name_long":"East Hammond Road","street_name_short":"E Hammond Rd","city":"Traverse City","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49686"},"%_mmi_phone%":"(231) 947-2770","%_mmi_url%":"www.timberridgeresort.net","%_wpgmp_location_address%":"4050 Hammond Road East, Traverse City, MI 49686","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_fusion%":"","%avada_post_views_count%":"1374","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-01-31","%_wpgmp_metabox_latitude%":"44.7142423","%_wpgmp_metabox_longitude%":"-85.494468","%_thumbnail_id%":"74239","taxonomy=portfolio_category":"Cabin Rentals, Cable TV, Camp Store, Campgrounds, Full Hook-Up, Laundry Facilities, Northwest Michigan Region, Online Reservations, Pet Friendly, Planned Activities, Pull-Through Sites, Recreation Facilities, Sells Propane Gas, Swimming, Tent Sites, WiFi Available, Year-Round Camping","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":74212,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Chain O Lakes Campground","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/chain-o-lakes-campground/\">Chain O Lakes Campground</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Family campground open seasonally April - November. Offers full hook up RV sites, tent sites, and cabins.<br /> 7231 South M 88 Bellaire, MI 49615","address":"7231 South M 88, Bellaire, MI 49615","location":{"lat":"44.9261082","lng":"-85.184232","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/chain-o-lakes-campground/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Family campground open seasonally April - November. Offers full hook up RV sites, tent sites, and cabins.<br /> 7231 South M 88 Bellaire, MI 49615","post_content":"[mmi_map]\r\n\r\n <h1>Chain O Lakes Campground</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nFamily campground open seasonally April - November. Offers full hook up RV sites, tent sites, and cabins.\r\n\r\n7231 South M 88\r\nBellaire, MI 49615\r\n\r\n<strong>\r\n\r\nPhone: (231) 533-8432\r\n Website: <a href=\"http://www.chainolakescamp.com/\" target=\"_blank\" rel=\"noopener\">www.chainolakescamp.com/</a>\r\nemail: <a href=\"mailto:admin@chainolakescamp.com\">admin@chainolakescamp.com</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nFull Hook-Up\r\nSwimming\r\nLaundry Facilities\r\nCamp Store\r\nWiFi Available\r\nPet Friendly\r\nPull-Through Sites\r\nTent Sites\r\nCabin Rentals\r\nOnline Reservations\r\n\r\n\r\n     ","post_title":"Chain O Lakes Campground","post_link":"https://www.michiganrvandcampgrounds.org/member-info/chain-o-lakes-campground/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chain O Lakes Campground\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2022/01/c18-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"7231 South M 88, Bellaire, MI 49615","errors":[],"address_formatted":"7231 M-88, Bellaire, MI 49615, USA","lat":"44.9261082","lng":"-85.184232","street_number":"7231","street_name_long":"Michigan 88","street_name_short":"M-88","city":"Bellaire","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49615"},"%_mmi_phone%":"(231) 533-8432","%_mmi_url%":"www.chainolakescamp.com/","%_wpgmp_location_address%":"7231 South M 88, Bellaire, MI 49615","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_wpgmp_metabox_latitude%":"44.9261082","%_wpgmp_metabox_longitude%":"-85.184232","%_fusion%":"","%avada_post_views_count%":"772","%avada_today_post_views_count%":"1","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2023-03-28","%_thumbnail_id%":"74269","taxonomy=portfolio_category":"Cabin Rentals, Camp Store, Campgrounds, Full Hook-Up, Laundry Facilities, Northwest Michigan Region, Online Reservations, Pet Friendly, Pull-Through Sites, Swimming, Tent Sites, WiFi Available","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":75288,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Northgate Leelanau Pines LLC","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/northgate-leelanau-pines-llc/\">Northgate Leelanau Pines LLC</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Our campground is located on the southern end of Lake Leelanau, just outside the village of Cedar. Our camping season runs from May - October, and we offer both seasonal and short stay reservations. Our guests have immediate lake access for swimming and boating, as well as bathrooms and showers, on site laundry, playground, jumping pad, pickleball/basketball court, arcade, and more.<br /> 6500 East Leelanau Pines Drive Cedar, MI 49621","address":"6500 East Leelanau Pines Drive, Cedar, MI 49621","location":{"lat":"44.8674145","lng":"-85.73171","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/northgate-leelanau-pines-llc/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Our campground is located on the southern end of Lake Leelanau, just outside the village of Cedar. Our camping season runs from May - October, and we offer both seasonal and short stay reservations. Our guests have immediate lake access for swimming and boating, as well as bathrooms and showers, on site laundry, playground, jumping pad, pickleball/basketball court, arcade, and more.<br /> 6500 East Leelanau Pines Drive Cedar, MI 49621","post_content":"[mmi_map]\r\n\r\n <h1>Northgate Leelanau Pines LLC</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nOur campground is located on the southern end of Lake Leelanau, just outside the village of Cedar. Our camping season runs from May - October, and we offer both seasonal and short stay reservations. Our guests have immediate lake access for swimming and boating, as well as bathrooms and showers, on site laundry, playground, jumping pad, pickleball/basketball court, arcade, and more.\r\n\r\n6500 East Leelanau Pines Drive\r\nCedar, MI 49621\r\n\r\n<strong>\r\n\r\nPhone: (231) 228-5742\r\n Website: <a href=\"http://www.leelanaupinescampresort.com\" target=\"_blank\" rel=\"noopener\">www.leelanaupinescampresort.com</a>\r\nemail: <a href=\"mailto:info@leelanaupines.com\">info@leelanaupines.com</a>\r\n</strong>\r\n\r\n <b>Features</b>\r\n\r\nSwimming\r\nLaundry Facilities\r\nFishing\r\nRecreation Facilities\r\n\r\n\r\n     ","post_title":"Northgate Leelanau Pines LLC","post_link":"https://www.michiganrvandcampgrounds.org/member-info/northgate-leelanau-pines-llc/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Northgate Leelanau Pines LLC\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2023/06/c24-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"6500 East Leelanau Pines Drive, Cedar, MI 49621","errors":[],"address_formatted":"6500 E Leelanau Pines Dr, Cedar, MI 49621, USA","lat":"44.8674145","lng":"-85.73171","street_number":"6500","street_name_long":"East Leelanau Pines Drive","street_name_short":"E Leelanau Pines Dr","city":"Cedar","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49621"},"%_mmi_phone%":"(231) 228-5742","%_mmi_url%":"www.leelanaupinescampresort.com","%_wpgmp_location_address%":"6500 East Leelanau Pines Drive, Cedar, MI 49621","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"90\";}","%_wpgmp_metabox_latitude%":"44.8674145","%_wpgmp_metabox_longitude%":"-85.73171","%_fusion%":"","%avada_post_views_count%":"435","%avada_today_post_views_count%":"2","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2023-06-26","%_thumbnail_id%":"75464","taxonomy=portfolio_category":"Campgrounds, Fishing, Laundry Facilities, Northwest Michigan Region, Recreation Facilities, Swimming","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png"},"id":75499,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","name":"Campground","id":"90","type":"category"}]},{"source":"post","title":"Pine Brook Properties","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/pine-brook-properties/\">Pine Brook Properties</a></div>\r\n</div>","content":"Northwest Michigan Region<br /><br /> 1503 N Garfield Road Traverse City, MI 49696","address":"1503 N Garfield Road , Traverse City, MI 49696","location":{"lat":"44.7077231","lng":"-85.5957352","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/pine-brook-properties/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br /><br /> 1503 N Garfield Road Traverse City, MI 49696","post_content":"[mmi_map]\r\n\r\n <h1>Pine Brook Properties</h1>\r\n<h2>Northwest Michigan Region</h2>\r\n\r\n\r\n1503 N Garfield Road\r\nTraverse City, MI 49696\r\n\r\n<strong>\r\nPhone: (231) 645-5500\r\n</strong>\r\n\r\n\r\n\r\n&nbsp;\r\n\r\n     ","post_title":"Pine Brook Properties","post_link":"https://www.michiganrvandcampgrounds.org/member-info/pine-brook-properties/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pine Brook Properties\" width=\"300\" height=\"200\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2021/04/s12-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_mmi_location%":{"geocoded":true,"address_raw":"1503 N Garfield Road , Traverse City, MI 49696","errors":[],"address_formatted":"1503 N Garfield Rd, Traverse City, MI 49696, USA","lat":"44.7077231","lng":"-85.5957352","street_number":"1503","street_name_long":"North Garfield Road","street_name_short":"N Garfield Rd","city":"Traverse City","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49696"},"%_mmi_phone%":"(231) 645-5500","%_mmi_url%":"","%_wpgmp_location_address%":"1503 N Garfield Road , Traverse City, MI 49696","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"92\";}","%_fusion%":"","%avada_post_views_count%":"2408","%avada_today_post_views_count%":"7","%avada_post_views_count_today_date%":"26-04-2024","%_wp_old_date%":"2022-02-04","%_wpgmp_metabox_latitude%":"44.7077231","%_wpgmp_metabox_longitude%":"-85.5957352","%_thumbnail_id%":"73583","taxonomy=portfolio_category":"Northwest Michigan Region, Services","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/Services-e1456842846466.png"},"id":74353,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/Services-e1456842846466.png","name":"Services","id":"92","type":"category"}]},{"source":"post","title":"Stromberg Carlson Products","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/stromberg-carlson-products/\">Stromberg Carlson Products</a></div>\r\n</div>","content":"Northwest Michigan Region<br />Stromberg supplies warehouse distributers and OEM products for travel trailers, 5th wheels and other RV products. Our product line includes electric tongue jacks, entry steps, hand-rails, ladders for RVs, bike racks, stabilizing jacks, platform straps, dryers, etc... Stromberg is not a retail outlet, but does sell online through website.<br /> 2323 Traversefield Drive Traverse City, MI 49686","address":"2323 Traversefield Drive, Traverse City, MI 49686","location":{"lat":"44.7193505","lng":"-85.5875485","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/stromberg-carlson-products/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />Stromberg supplies warehouse distributers and OEM products for travel trailers, 5th wheels and other RV products. Our product line includes electric tongue jacks, entry steps, hand-rails, ladders for RVs, bike racks, stabilizing jacks, platform straps, dryers, etc... Stromberg is not a retail outlet, but does sell online through website.<br /> 2323 Traversefield Drive Traverse City, MI 49686","post_content":"[mmi_map]\r\n\r\n <h1>Stromberg Carlson Products</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nStromberg supplies warehouse distributers and OEM products for travel trailers, 5th wheels and other RV products. Our product line includes electric tongue jacks, entry steps, hand-rails, ladders for RVs, bike racks, stabilizing jacks, platform straps, dryers, etc... Stromberg is not a retail outlet, but does sell online through website.\r\n\r\n2323 Traversefield Drive\r\nTraverse City, MI 49686\r\n\r\n<strong>\r\nPhone: (231) 947-8600\r\nFax: (231) 947-7006\r\nWebsite: <a href=\"https://www.strombergcarlson.com/\" target=\"_blank\" rel=\"noopener\">https://www.strombergcarlson.com/</a>\r\n</strong>\r\n\r\nSells Parts &amp; Accessories\r\n\r\n\r\n&nbsp;\r\n\r\n     ","post_title":"Stromberg Carlson Products","post_link":"https://www.michiganrvandcampgrounds.org/member-info/stromberg-carlson-products/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Stromberg Carlson Products\" width=\"300\" height=\"225\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2018/11/s1-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%c4p_log_redirect_to%":null,"%_mmi_location%":{"geocoded":true,"address_raw":"2323 Traversefield Drive, Traverse City, MI 49686","errors":[],"address_formatted":"2323 Traversefield Dr, Traverse City, MI 49686, USA","lat":"44.7193505","lng":"-85.5875485","street_number":"2323","street_name_long":"Traversefield Drive","street_name_short":"Traversefield Dr","city":"Traverse City","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49686"},"%_mmi_phone%":"(231) 947-8600","%_mmi_url%":"https://www.strombergcarlson.com/","%_wpgmp_location_address%":"2323 Traversefield Drive, Traverse City, MI 49686","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"92\";}","%_wpgmp_metabox_latitude%":"44.7193505","%_wpgmp_metabox_longitude%":"-85.5875485","%_wp_old_date%":"2018-04-04","%_fusion%":"","%avada_post_views_count%":"2633","%avada_today_post_views_count%":"7","%avada_post_views_count_today_date%":"26-04-2024","%_thumbnail_id%":"65473","taxonomy=portfolio_category":"Northwest Michigan Region, Sells Parts &amp; Accessories, Services","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/Services-e1456842846466.png"},"id":41610,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/Services-e1456842846466.png","name":"Services","id":"92","type":"category"}]},{"source":"post","title":"VP Demand Creation Services","infowindow_content":"<div class=\"post_body\">\r\n<div class=\"geotags_link\"><a  href=\"https://www.michiganrvandcampgrounds.org/member-info/vp-demand-creation-services/\">VP Demand Creation Services</a></div>\r\n</div>","content":"Northwest Michigan Region<br />VPDCS is a fulfillment specialist, data manager, direct marketer, viral marketer, consumer and enthusiast magazine publisher, book publisher, and printing company. We meet today&#x2019;s serious marketing challenges with an extraordinary variety of tools. We help our clients implement their marketing strategies &#x2014; segment-by-segment, offer-by-offer, handling out-bound and in-bound marketing, across multiple media &#x2014; by being a single-source marketing solution and business development provider.<br /> 2779 Aero Park Drive Traverse City, MI 49685-0968","address":"2779 Aero Park Drive, Traverse City, MI 49685-0968","location":{"lat":"44.743287","lng":"-85.5669052","onclick_action":"marker","redirect_permalink":"https://www.michiganrvandcampgrounds.org/member-info/vp-demand-creation-services/","zoom":7,"extra_fields":{"post_excerpt":"Northwest Michigan Region<br />VPDCS is a fulfillment specialist, data manager, direct marketer, viral marketer, consumer and enthusiast magazine publisher, book publisher, and printing company. We meet today&#x2019;s serious marketing challenges with an extraordinary variety of tools. We help our clients implement their marketing strategies &#x2014; segment-by-segment, offer-by-offer, handling out-bound and in-bound marketing, across multiple media &#x2014; by being a single-source marketing solution and business development provider.<br /> 2779 Aero Park Drive Traverse City, MI 49685-0968","post_content":"[mmi_map]\r\n\r\n<img class=\"alignright wp-image-25447\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2017/06/VPDCS_CMYK_v.jpg\" alt=\"\" width=\"180\" /><h1>VP Demand Creation Services</h1>\r\n<h2>Northwest Michigan Region</h2>\r\nVPDCS is a fulfillment specialist, data manager, direct marketer, viral marketer, consumer and enthusiast magazine publisher, book publisher, and printing company. We meet today&#x2019;s serious marketing challenges with an extraordinary variety of tools. We help our clients implement their marketing strategies &#x2014; segment-by-segment, offer-by-offer, handling out-bound and in-bound marketing, across multiple media &#x2014; by being a single-source marketing solution and business development provider.\r\n\r\n2779 Aero Park Drive\r\nTraverse City, MI 49685-0968\r\n\r\n<strong>\r\nPhone: (231) 946-7770\r\nWebsite: <a href=\"https://vpdcs.com/\" target=\"_blank\" rel=\"noopener\">https://vpdcs.com/</a>\r\n</strong>\r\n\r\n\r\n\r\n&nbsp;\r\n\r\n<img class=\"aligncenter size-full wp-image-24605\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2017/06/IMG_2251.JPG.jpeg\" />\r\n    ","post_title":"VP Demand Creation Services","post_link":"https://www.michiganrvandcampgrounds.org/member-info/vp-demand-creation-services/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"VP Demand Creation Services\" width=\"300\" height=\"225\" src=\"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2017/06/IMG_2251.JPG-300x225.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%c4p_log_redirect_to%":null,"%_mmi_location%":{"geocoded":true,"address_raw":"2779 Aero Park Drive, Traverse City, MI 49685-0968","errors":[],"address_formatted":"2779 Aero-Park Dr, Traverse City, MI 49686, USA","lat":"44.743287","lng":"-85.5669052","street_number":"2779","street_name_long":"Aero-Park Drive","street_name_short":"Aero-Park Dr","city":"Traverse City","state_long":"Michigan","state_short":"MI","country_long":"United States","country_short":"US","zip":"49686"},"%_mmi_phone%":"(231) 946-7770","%_mmi_url%":"https://vpdcs.com/","%_wpgmp_location_address%":"2779 Aero Park Drive, Traverse City, MI 49685-0968","%_wpgmp_map_id%":"a:1:{i:0;s:2:\"11\";}","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"92\";}","%_edit_lock%":"1497905647:1","%_wpgmp_metabox_latitude%":"44.743287","%_wpgmp_metabox_longitude%":"-85.5669052","%_wp_old_date%":"2018-04-04","%_fusion%":"","%avada_post_views_count%":"4546","%avada_today_post_views_count%":"10","%avada_post_views_count_today_date%":"26-04-2024","%_thumbnail_id%":"46756","taxonomy=portfolio_category":"Northwest Michigan Region, Services","taxonomy=portfolio_skills":"","taxonomy=portfolio_tags":""},"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/Services-e1456842846466.png"},"id":41634,"infowindow_disable":false,"categories":[{"icon":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/Services-e1456842846466.png","name":"Services","id":"92","type":"category"}]}],"styles":"[{\"featureType\":\"administrative\",\"elementType\":\"labels.text.fill\",\"stylers\":[{\"color\":\"#444444\"}]},{\"featureType\":\"administrative.country\",\"elementType\":\"geometry.fill\",\"stylers\":[{\"saturation\":\"29\"},{\"visibility\":\"on\"}]},{\"featureType\":\"landscape\",\"elementType\":\"all\",\"stylers\":[{\"color\":\"#f2f2f2\"}]},{\"featureType\":\"poi\",\"elementType\":\"all\",\"stylers\":[{\"visibility\":\"off\"}]},{\"featureType\":\"road\",\"elementType\":\"all\",\"stylers\":[{\"saturation\":-100},{\"lightness\":45}]},{\"featureType\":\"road.highway\",\"elementType\":\"all\",\"stylers\":[{\"visibility\":\"simplified\"}]},{\"featureType\":\"road.arterial\",\"elementType\":\"labels.icon\",\"stylers\":[{\"visibility\":\"off\"}]},{\"featureType\":\"transit\",\"elementType\":\"all\",\"stylers\":[{\"visibility\":\"off\"}]},{\"featureType\":\"water\",\"elementType\":\"all\",\"stylers\":[{\"color\":\"#46bcec\"},{\"visibility\":\"on\"}]}]","listing":{"listing_header":"<h2>Map Locations</h2>","display_search_form":false,"search_field_autosuggest":false,"display_category_filter":true,"display_sorting_filter":false,"display_radius_filter":false,"radius_dimension":"miles","radius_options":"5,10,15,20,25,50,100,200,500","apply_default_radius":false,"default_radius_dimension":"miles","display_location_per_page_filter":false,"display_print_option":false,"display_grid_option":false,"filters":["place_category"],"sorting_options":{"category__asc":"A-Z Category","category__desc":"Z-A Category","title__asc":"A-Z Title","title__desc":"Z-A Title","address__asc":"A-Z Address","address__desc":"Z-A Address"},"default_sorting":{"orderby":"title","inorder":"asc"},"listing_container":".location_listing11","tabs_container":".location_listing11","hide_locations":false,"filters_position":"default","hide_map":false,"pagination":{"listing_per_page":"10"},"list_grid":"wpgmp_listing_grid","listing_placeholder":"<div class=\"wpgmp_locations\">\r\n    <div class=\"wpgmp_locations_head\">\r\n        <div class=\"wpgmp_location_title\">\r\n            <a href=\"\" class=\"place_title\" data-zoom=\"{marker_zoom}\" data-marker=\"{marker_id}\">{marker_title}</a>\r\n        </div>\r\n        <div class=\"wpgmp_location_meta\">\r\n            <span class=\"wpgmp_location_category fc-badge info\">{marker_category}</span>\r\n        </div>\r\n    </div>\r\n    <div class=\"wpgmp_locations_content\">\r\n    {marker_message}\r\n    </div>\r\n    <div class=\"wpgmp_locations_foot\"></div>\r\n</div>","list_item_skin":{"name":"default","type":"item","sourcecode":"<div class=\"wpgmp_locations\">\r\n    <div class=\"wpgmp_locations_head\">\r\n        <div class=\"wpgmp_location_title\">\r\n            <a href=\"\" class=\"place_title\" data-zoom=\"{marker_zoom}\" data-marker=\"{marker_id}\">{marker_title}</a>\r\n        </div>\r\n        <div class=\"wpgmp_location_meta\">\r\n            <span class=\"wpgmp_location_category fc-badge info\">{marker_category}</span>\r\n        </div>\r\n    </div>\r\n    <div class=\"wpgmp_locations_content\">\r\n    {marker_message}\r\n    </div>\r\n    <div class=\"wpgmp_locations_foot\"></div>\r\n</div>"}},"map_property":{"map_id":"11","debug_mode":true},"shapes":{"drawing_editable":false},"filters":{"filters_container":"[data-container=\"wpgmp-filters-container\"]"},"marker_category_icons":{"90":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/campground-1-e1456842699189.png","91":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/dealer-e1456842808766.png","92":"https://www.michiganrvandcampgrounds.org/wp-content/uploads/2016/03/Services-e1456842846466.png"}}
Related Posts
MARVAC2023-08-31T09:59:29-04:00
Three Fall Trails in Northwest Michigan
MARVAC2023-08-31T09:59:29-04:00September 10th, 2023|
Autumn is a special time in Michigan. The vast wilderness looks like an impressionist’s painting, and the bursts of color found throughout cities and towns pop with joyous flare. The [...]
MARVAC2022-11-29T10:50:05-05:00
West Michigan Pike Part 2
MARVAC2022-11-29T10:50:05-05:00November 29th, 2022|
Mileage: 284 miles Driving Time: 6 hours, 20 minutes In Part 1 of this article, we drove from the southwest corner of the state all the way up the Lake [...]
MARVAC2022-10-17T21:53:05-04:00
Travel Around Grand Traverse Bay in Northwest Michigan
MARVAC2022-10-17T21:53:05-04:00October 17th, 2022|
Grand Traverse Bay in northwest Lower Michigan is really one large expanse of water separated by Old Mission Peninsula, effectively “splitting” it into East and West Grand Traverse Bay. The [...]
MARVAC2022-03-22T13:13:38-04:00
Michigan Destinations for Roadschooling Families
MARVAC2022-03-22T13:13:38-04:00March 22nd, 2022|
Roadschooling, nomadic education in other words, has blossomed the past several years as remote work better enables working parents to travel more accessibly. An RV helps to make that possible, [...]