New York City

Bezienswaardigheden New York Boottochten New York Rondleidingen New York Hotspots New York Foodmarkets New York Musea New York Parken New York Wijken New York
Staten Island Ferry met het Vrijheidsbeeld op de achtergrond
Pak de gratis Staten Island Ferry in New York
{"map_options":{"center_lat":"39.729935411363066","center_lng":"-101.70329621023899","zoom":12,"map_type_id":"HYBRID","center_by_nearest":false,"fit_bounds":false,"center_circle_fillcolor":"#8CAEF2","center_circle_strokecolor":"#8CAEF2","show_center_circle":false,"show_center_marker":false,"center_marker_icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/01/4.png","draggable":true,"scroll_wheel":"true","gesture":"auto","marker_default_icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png","infowindow_setting":"<div class=\"fc-item-box fc-item-no-padding\">\n<div class=\"fc-itemcontent-padding\">\n<div class=\"fc-item-padding-content_20\">\n<div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">{marker_category}</div>\n<div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">{marker_title}</div>\n<div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\n<div class=\"fc-button\"><a href=\"{button}\"><strong>LEES MEER:</strong></a></div>\n</p></div>\n</p></div>\n</p></div>\n</div>\n","infowindow_geotags_setting":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    {post_featured_image}\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">{post_title}</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","infowindow_skin":{"name":"udine","type":"infowindow","sourcecode":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">{marker_category}</div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">{marker_title}</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n <div class=\"fc-button\"><a href=\"{button}\"><strong>LEES MEER:</strong></a></div>\r\n            </div>\r\n\r\n        </div>\r\n    </div>\r\n</div>"},"infowindow_post_skin":{"name":"aare","type":"post","sourcecode":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    {post_featured_image}\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">{post_title}</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></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":true,"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":true,"bound_map_after_filter":false,"display_reset_button":false,"map_reset_button_text":"Reset","width":"100%","height":"550"},"places":[{"source":"post","title":"Megaroof van miljoenen dollars in Los Angeles","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Megaroof van tientallen miljoenen in Los Angeles\" width=\"300\" height=\"218\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/04/bankkluis-300x218.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Megaroof van miljoenen dollars in Los Angeles</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"","address":"Sylmar, Los Angeles, Californi\u00eb, Verenigde Staten","location":{"lat":"34.2994874","city":"Los Angeles","state":"Californi\u00eb","country":"Verenigde Staten","lng":"-118.4588292","redirect_custom_link":"","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/megaroof-van-miljoenen-dollars-in-los-angeles/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_custom_heading text=\"Net als in de film (of tv) een megaroof van tientallen miljoenen in LA\" font_container=\"tag:h2|font_size:30|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><strong>Je zou bijna denken dat er nieuwe opnames plaats hebben gevonden van 'La Casa de Papel' of 'Money Heist' in het Engels. Maar niets is minder waar,\u00a0inbrekers hebben 30 miljoen dollar (ruim 27 miljoen euro) gestolen uit een geldopslag in Los Angeles. Het zou gaan om \u00e9\u00e9n van de grootste diefstallen van contant geld in de Amerikaanse stad ooit.</strong></p>\r\n[/vc_column_text][vc_column_text]De politie van Los Angeles en de FBI onderzoeken de diefstal van tientallen miljoenen dollars uit een geldopslagplaats in de San Fernando Valley, in de wijk Sylmar dichtbij Burbank.\r\n<h3>Dieven bleven onopgemerkt: het alarm ging niet af!</h3>\r\nDe dieven braken onopgemerkt het pand binnen - zonder het alarm te laten afgaan - via het dak. Hiermee wisten ze op een of andere manier de geldopslagruimte binnen te dringen. Bovendien toont de kluis van buitenaf geen sporen van inbraak. Het bedrijf dat eigenaar is van het gebouw ontdekte de massale diefstal pas de ochtend later. Hoe het de dieven is gelukt om zoveel geld buit te maken, is een mysterie.\r\n<h3>LAPD werkt samen met de FBI aan het onderzoek</h3>\r\nLAPD (Los Angeles Police Department) zegt dat de dienst samenwerkt met de FBI aan deze zaak. Het is onduidelijk hoeveel er precies is gestolen, maar er wordt aangenomen dat het een van de grootste overvallen in de geschiedenis van LA is.\r\n\r\nDe verfijnde aanpak van de overval doet de autoriteiten geloven dat een professionele en ervaren inbrekers verantwoordelijk zijn voor de brutale inbraak. Het is nog onduidelijk om wie het gaat.\r\n\r\n[caption id=\"attachment_19595\" align=\"alignleft\" width=\"1024\"]<img class=\"size-large wp-image-19595\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/04/brinks-money-truck-1024x745.jpg\" alt=\"Een Brinks waardetransport truck in Pasadena\" width=\"1024\" height=\"745\" /> Een Brinks waardetransport truck in Pasadena[/caption]\r\n<h3>Twee jaar na andere grote roof in Los Angeles</h3>\r\nDe diefstal komt bijna twee jaar nadat maar liefst $100 miljoen aan juwelen en andere waardevolle spullen werd gestolen uit een waardetransportwagen van Brink's bij een vrachtwagenstopplaats in Zuid-Californi\u00eb. Ook deze dieven zijn nooit gepakt.[/vc_column_text][vc_column_text][/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"95%\"][ultimate_heading main_heading=\"Meer #Trending Amerika nieuws\" main_heading_color=\"#b34a4c\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\"][/ultimate_heading][vc_empty_space height=\"25px\"][thb_postgrid columns=\"5\" pagination=\"style2\" source=\"size:10|post_type:post|categories:198,199,200,205,201\"][/vc_column][/vc_row]","post_title":"Megaroof van miljoenen dollars in Los Angeles","post_link":"https://www.heyusa.com/nl/megaroof-van-miljoenen-dollars-in-los-angeles/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Megaroof van tientallen miljoenen in Los Angeles\" width=\"300\" height=\"218\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/04/bankkluis-300x218.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Trending Los Angeles","post_tags":"","%_last_editor_used_jetpack%":"classic-editor","%_edit_lock%":"1712237470:1","%_edit_last%":"1","%_thumbnail_id%":"19593","%_yoast_indexnow_last_ping%":"1712237466","%_hide_featured%":null,"%_wpgmp_location_address%":"Sylmar, Los Angeles, Californi\u00eb, Verenigde Staten","%_wpgmp_location_city%":"Los Angeles","%_wpgmp_location_state%":"Californi\u00eb","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"34.2994874","%_wpgmp_metabox_longitude%":"-118.4588292","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_metadesc%":"Het lijkt op een aflevering van La Casa de Papel, maar inbrekers in LA wisten onopgemerkt tientallen miljoenen te stelen tijdens een inbraak.","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"zonsverduistering van 2024 in 13 staten\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%post-primary-category%":"auto","%featured_image_override%":"off","%standard-featured-credit%":"","%post_source%":"","%article_style_override%":"on","%post_style%":"style8","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%inline_featured_image%":"0","%_yoast_wpseo_primary_category%":"205","%_yoast_wpseo_focuskw%":"Megaroof van tientallen miljoenen in Los Angeles","%_yoast_wpseo_linkdex%":"66","%_yoast_wpseo_title%":"Megaroof van tientallen miljoenen in Los Angeles","%post_via%":"","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","taxonomy=category":"Trending Los Angeles","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/buurt-1.png"},"id":19592,"custom_filters":[],"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/buurt-1.png","name":"Buurten","id":"1","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"De meest luxueuze resorts in Las Vegas","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Luxueuze resorts in Las Vegas\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/03/luxe-hotels-in-las-vegas-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">De meest luxueuze resorts in Las Vegas</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"Alleen al voor het uitzicht vanuit de Delfts blauwe kamers, wil je hier logeren. Het NoMo in de wijk SoHo is #wow. ","address":"9 Crosby St, New York, NY 10013, Verenigde Staten","location":{"lat":"40.719835362954925","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-74.00008498650817","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/luxueuze-hotels-las-vegas/","zoom":12,"extra_fields":{"post_excerpt":"Alleen al voor het uitzicht vanuit de Delfts blauwe kamers, wil je hier logeren. Het NoMo in de wijk SoHo is #wow. ","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Genieten van een luxe hotel?\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][ultimate_heading main_heading=\"Dit zijn de beste resorts in Las Vegas\" heading_tag=\"div\" main_heading_font_family=\"font_family:Oswald|font_call:Oswald\" main_heading_font_size=\"desktop:30px;\" main_heading_line_height=\"desktop:35px;\"][/ultimate_heading][vc_column_text]Genieten van ultieme luxe en even ontspannen na alle hectiek op de Strip? Dan zijn deze hotels de beste opties om te overnachten in Las Vegas. Luxe resorts waar je alle faciliteiten kunt vinden die je maar wenst. Verschillende zwembaden, fitness en spa ruimtes, piekfijne restaurants en kamers waar je niet meer af wilt, dit zijn de beste hotels van Las Vegas wil je echt ultiem genieten van luxe.[/vc_column_text][vc_column_text]\r\n<p style=\"text-align: center;\">\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Crockfords Palace Suite (Resorts World)\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Er zijn genoeg hotels op de <a href=\"https://www.heyusa.com/nl/las-vegas/the-strip-las-vegas/\">Strip</a> waar je kunt verblijven als je Las Vegas bezoekt. The Resort World combineert het beste van alles. Residenties van beroemdheden, goede restaurants, zwembaden, een gamescene, winkels en een fantastische spa, je hoeft het hotel niet meer uit. Het resort heeft geen specifiek thema, maar je vindt er vooral een residenti\u00eble sfeer. Vanaf de kamers heb je uitzicht op Las Vegas Valley en de bergen in het westen. Er zijn drie verschillende hotelingangen; het Hilton biedt de goedkoopste kamers, bij het Conrad krijg je iets meer luxe en in het Crockfords vind je penthouses, villa's en suites. Eetmogelijkheden genoeg waaronder Famous Foods Street Eats, een verzameling van meer dan 15 foodcourts met Zuidoost- Aziatisch eten. Favorieten zijn onder andere Famous Pho, Harajuku Ramen en Burger Barn. De spa is misschien nog wel de meest unieke van alle spa's in Las Vegas. Niet alleen heb je de mogelijkheid tot een uitgebreide behandeling, ook voor een snelle voet-spabehandeling kun je hier terecht.[/vc_column_text][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"3000 Las Vegas Boulevard S\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"Gratis WiFi\"][thb_iconlist icon=\"fas fa-swimmer\" list_content=\"Zwembad\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Comfortabele bedden\"][thb_iconlist icon=\"fas fa-running\" list_content=\"Gym\"][thb_iconlist icon=\"fas fa-spa\" list_content=\"Welnesscentrum\"][thb_iconlist icon=\"fas fa-utensils\" list_content=\"Restaurant\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer bij Conrad\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fconrad-las-vegas-at-resorts-world.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dluxehotelslasvegasconrad|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][ult_buttons btn_title=\"Boek een kamer bij Crockfords\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fcrockfords-las-vegas-lxr-hotels-resorts.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dluxehotelslasvegascrockfords|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][ult_buttons btn_title=\"Boek een kamer bij Hilton\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Flas-vegas-hilton-at-resorts-world.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dluxehotelslasvegashilton|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"19534,19535,19536,19537\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Fontainebleau\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Fontainebleau in Las Vegas is een van de nieuwste hotels op de Strip. Je vindt er een fijne mix aan entertainment, maar kunt ook ontsnappen aan het nachtleven waar de stad om bekend staat. Het hotel beschikt over meer dan 3500 kamers die uitzicht hebben op de Strip. Ontspanning kan niet ontbreken met 7 zwembaden, een 150.000 vierkante meter casino en veel aanbod in restaurants. De luxe suites hebben zachte loungestoelen en geven je de mogelijkheid om een potje pool te spelen. Vooral de Lapis Spa is een aanrader om bijvoorbeeld een massage of een gezichtsbehandeling te krijgen. Ook hydrotherapie met vitaliteitsbaden, koude duiksessies en aromatherapie behoren tot de mogelijkheden. Op een actieve manier ontspannen? Dat kan in het fitnesscentrum waar gratis groepslessen worden gegeven.[/vc_column_text][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"2777 S Las Vegas Boulevard\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"WiFi\"][thb_iconlist icon=\"fas fa-swimmer\" list_content=\"Zwembad\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Comfortabele bedden\"][thb_iconlist icon=\"fas fa-running\" list_content=\"Gym\"][thb_iconlist icon=\"fas fa-spa\" list_content=\"Welnesscentrum\"][thb_iconlist icon=\"fas fa-utensils\" list_content=\"Restaurant\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Ffontainebleau-las-vegas-las-vegas98.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dluxehotelslasvegasfontainebleau|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"19529,19528,19527,19526\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Nobu Hotel\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Het Nobu Hotel in Las Vegas brengt je in Japanse sferen. Ontdek je zen tijdens de luxe overnachting in het Nobu Hotel in Las Vegas. Kom tot rust en ervaar de speciale aandacht zoals je dat in een boetiekhotel mag verwachten. Services als een butler, limousine vervoer, een tuin en bubbelbad en een VIP behandeling in het restaurant zorgen ervoor dat je graag in het hotel wilt blijven. Je kunt zelfs genieten van een diner op je kamer gemaakt door de Nobu chefs. En de Japanse Hokusetsu brouwerij laat je kennismaken met zelfgebrouwen biertjes.[/vc_column_text][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"4455 Paradise Road\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"WiFi\"][thb_iconlist icon=\"fas fa-swimmer\" list_content=\"Zwembad\"][thb_iconlist icon=\"fas fa-binoculars\" list_content=\"Rooftop\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Comfortabele bedden\"][thb_iconlist icon=\"fas fa-running\" list_content=\"Gym\"][thb_iconlist icon=\"fas fa-spa\" list_content=\"Welnesscentrum\"][thb_iconlist icon=\"fas fa-utensils\" list_content=\"Restaurant\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fnobu-at-caesars-palace.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dluxehotelslasvegasnobu|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"19530,19531,19532,19533\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"The Venetian\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Veneti\u00eb in Las Vegas. Er zijn vele thema hotels in de stad te vinden. Een van de meest luxe thema hotels is The Venetian, een eerbetoon aan de stad Veneti\u00eb. Met meer dan 7000 kamers is het op \u00e9\u00e9n na grootste hotel ter wereld. Replica's als het San Marcoplein, kanalen met gondeliers en de Canal Grande kunnen niet ontbreken. The Venetian is niet alleen luxe overnachten, het resort heeft ook winkels, een foodcourt, een van de beste Chinese restaurants van Amerika en zelfs nog verborgen plekken zoals Thomas Keller's Bouchon op de 10e verdieping van de toren. Natuurlijk kunnen voorzieningen zoals een spa, fitness, een klimmuur, acupunctuur en grote hotelkamers niet ontbreken in een hotel als dit.[/vc_column_text][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"3600 S Las Vegas Boulevard\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"Gratis WiFi\"][thb_iconlist icon=\"fas fa-swimmer\" list_content=\"Zwembad\"][thb_iconlist icon=\"fas fa-binoculars\" list_content=\"Rooftop\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Comfortabele bedden\"][thb_iconlist icon=\"fas fa-running\" list_content=\"Gym\"][thb_iconlist icon=\"fas fa-spa\" list_content=\"Welnesscentrum\"][thb_iconlist icon=\"fas fa-utensils\" list_content=\"Restaurant\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fthe-venetian-resort-casino.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dluxehotelslasvegasvenetian|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"19522,19523,19524,19525\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wynn Villa\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Van casino hotel naar resort. Dat werd het Wynn hotel in 2005 toen er een golfbaan achter het hotel werd geopend. Tegelijkertijd werden ook priv\u00e9meren en watervallen gecre\u00eberd bij het hotel. Wynn is op en top glamour, je gaat niet naar Las Vegas, maar je gaat naar Wynn. In de kamers vind je op maat ontworpen meubilair, warme houten accenten en verschillende kunstwerken. Vergeet niet dat Wynn ook nog eens over excellente restaurants beschikt. Delilah doet denken aan het gouden tijdperk van de stad halverwege de eeuw. Natuurlijk kunnen speciale cocktailbars niet ontbreken. Denk aan Aft Cocktail Deck dat ge\u00efnspireerd is op het jachtleven. Of kijk uit over Lake of Dream met een cocktail in je hand.[/vc_column_text][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"3132 Las Vegas Boulevard\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"WiFi\"][thb_iconlist icon=\"fas fa-swimmer\" list_content=\"Zwembad\"][thb_iconlist icon=\"fas fa-binoculars\" list_content=\"Rooftop\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Comfortabele bedden\"][thb_iconlist icon=\"fas fa-running\" list_content=\"Gym\"][thb_iconlist icon=\"fas fa-utensils\" list_content=\"Restaurant\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fwynn-las-vegas-boulevard.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dluxehotelslasvegaswynn|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"19517,19518,19519,19520\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Las Vegas tips\" main_heading_color=\"#b34a4c\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"25px\"][thb_postgrid style=\"style4\" columns=\"4\" source=\"size:8|post_type:post|by_id:19478,17930,14660,4348\"][/vc_column][/vc_row]","post_title":"De meest luxueuze resorts in Las Vegas","post_link":"https://www.heyusa.com/nl/luxueuze-hotels-las-vegas/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Luxueuze resorts in Las Vegas\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/03/luxe-hotels-in-las-vegas-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Las Vegas","post_tags":"","%inline_featured_image%":"0","%_edit_lock%":"1711539689:2","%_edit_last%":"2","%_yoast_wpseo_primary_category%":"53","%_thumbnail_id%":"19540","%_hide_featured%":null,"%_wpgmp_location_address%":"9 Crosby St, New York, NY 10013, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.719835362954925","%_wpgmp_metabox_longitude%":"-74.00008498650817","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"13\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"luxe hotels las vegas\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%post-primary-category%":"auto","%featured_image_override%":"off","%standard-featured-credit%":"","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_focuskw%":"De meest luxueuze resorts in Las Vegas","%_yoast_wpseo_metadesc%":"De meest luxueuze resorts in Las Vegas, dit zijn de beste plekken om te overnachten in luxe in Las Vegas.","%_yoast_wpseo_linkdex%":"76","%post_source%":"","%_yoast_indexnow_last_ping%":"1711539661","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%executive_summary%":"Delfts blauw past bij jou!","%_last_editor_used_jetpack%":"classic-editor","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","%post_via%":[{"title":"Resorts World","post_source_url":"https://www.rwlasvegas.com/"},{"title":"Fontainebleau","post_source_url":"https://www.fontainebleaulasvegas.com/"},{"title":"Nobu","post_source_url":"https://www.caesars.com/nobu-caesars-palace"},{"title":"The Venetian","post_source_url":"https://www.venetianlasvegas.com/"},{"title":"The Wynn","post_source_url":""}],"taxonomy=category":"Las Vegas","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png"},"id":19514,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png","name":"Hotels","id":"13","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Valley of the Gods","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Valley of the Gods\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/03/valley-of-the-gods-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Valley of the Gods</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Valley of the Gods, Utah 84531, Verenigde Staten","location":{"lat":"37.26666790000001","state":"Utah","country":"Verenigde Staten","lng":"-109.8340136","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/valley-of-the-gods/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Valley of the Gods in Utah\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Rijd je tussen <a href=\"https://www.heyusa.com/nl/wat-te-doen-in-moab/\">Moab</a> en Monument Valley? Dan is de route door Valley of the Gods een aanrader om te nemen. Het is een kleine omweg, maar een die zeker de moeite waard is. Valley of the Gods is een kleinere versie van Monument Valley, een stuk minder bekend en daardoor is het er minder druk. Overal waar je kijkt zie je rode rotsformaties, buttes, mesa's en torenspitsen. Een indrukwekkend landschap dat je per auto kunt verkennen.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]700 kilometer vanaf Las Vegas[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]365 dagen per jaar[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Gratis[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\"]Beste periode: lente en herfst[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">390 km2</span>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Middle of Nowhere gevoel\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een bezoek aan Valley of the Gods voelt vooral alsof je in the middle of nowhere staat. Hoewel het gebied grotendeels lijkt op het populaire <a href=\"https://www.heyusa.com/nl/monument-valley/\">Monument Valley</a>, is het er rustiger. Er loopt een onverharde weg door het gebied, het is geen doorgaande weg, mensen moeten er een stukje voor omrijden. De totale lengte is 27 kilometer en redelijk begaanbaar met goed weer. Je kunt er in principe overheen met een gewone huurauto, high clearance wordt wel aangeraden. Het mooiste gedeelte vind je rondom Castle Butte waar je 'mesa walls' en rotsformaties kunt vinden. De beroemdste rotsformatie is Mexican Hatt die je ziet vanaf US-163.[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Scenic Drive\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"In Valley of the Gods\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"19461\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Hoe kom je bij Valley of the Gods?\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Je vindt Valley of the Gods op de weg tussen Moab en Monument Valley. Wanneer je Highway 163 neemt, kom je na enkele kilometers het plaatsje Bluff tegen, hierna neem je rechtsaf de Scenic Drive. Over deze weg doe je ongeveer een uurtje, hoewel stoppen om foto's te maken natuurlijk mogelijk is. Na de Scenic Drive kom je uit op Highway 261 vanwaar je door kunt naar Monument Valley. Omdat er in het gebied geen faciliteiten zijn is het handig om wat extra voorraden mee te nemen.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Overnachten in de buurt\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Valley of the Gods is eigenlijk alleen geschikt om doorheen te rijden, overnachten in het natuurgebied kan helaas niet. Daarvoor ben je aangewezen op plaatsen als Bluff waar je bijvoorbeeld het <a href=\"https://www.booking.com/hotel/us/bluff-dwellings-resort-bluff.en.html?aid=7958498&amp;no_rooms=1&amp;group_adults=2valleyofthegodsbluff\" target=\"_blank\" rel=\"noopener\">Bluff Dwellings Resort</a> of het <a href=\"https://www.booking.com/hotel/us/desert-rose-inn-cabins.en.html?aid=7958498&amp;no_rooms=1&amp;group_adults=2desertroseresort\" target=\"_blank\" rel=\"noopener\">Desert Rose Resort</a> vindt om te overnachten. Rijd je richting Monument Valley? Dan kun je overnachten bij <a href=\"https://www.booking.com/hotel/us/goulding-s-lodge.en.html?aid=7958498&amp;no_rooms=1&amp;group_adults=2goulding\" target=\"_blank\" rel=\"noopener\">Goulding's Lodge</a>.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Beste reisperiode om Valley of the Gods te bezoeken\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Valley of the Gods is het hele jaar geopend. De beste periode om Valley of the Gods te bezoeken is in de lente of de herfst. In de zomermaanden is het erg warm in het gebied en er zijn geen faciliteiten aanwezig. Daarnaast is het ook het seizoen van de moesson. Het mooiste moment van de dag is een zonsopkomst of zonsondergang. Het is goed om rekening te houden nat weer, de wegen zijn dan minder goed begaanbaar.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"De prachtige rode rotsformaties\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Net zo indrukwekkend als Monument Valley?\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"19460\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"75px\"][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ontdek meer natuur in de buurt\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][ultimate_heading main_heading=\"Nog meer Utah\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:40px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:45px;\"][/ultimate_heading][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"25px\"][thb_postbackground style=\"style2\" source=\"by_id:-16192,-16204,-16174,-16126,-15644,-15614,-15580,-1262,-2267,-572,-545,18916,4195,1273,4817\"][/vc_column][/vc_row]","post_title":"Valley of the Gods","post_link":"https://www.heyusa.com/nl/valley-of-the-gods/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Valley of the Gods\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/03/valley-of-the-gods-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Natuurgebieden","post_tags":"Utah","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%inline_featured_image%":"0","%_edit_lock%":"1711013721:2","%_edit_last%":"2","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Bonneville Salt Flats Utah\"]","%_yoast_wpseo_focuskw%":"Valley of the Gods","%_yoast_wpseo_metadesc%":"Ontdek Valley of the Gods in de staat Utah. Benieuwd wat je er kunt doen? Tips voor een bezoek aan de Valley of the Gods.","%_yoast_wpseo_linkdex%":"82","%_wpgmp_location_address%":"Valley of the Gods, Utah 84531, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Utah","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"37.26666790000001","%_wpgmp_metabox_longitude%":"-109.8340136","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_primary_category%":"227","%_yoast_wpseo_title%":"Valley of the Gods %%page%% %%sep%% %%sitename%%","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1711013084","%_last_editor_used_jetpack%":"classic-editor","%standard-featured-credit%":"","%_thumbnail_id%":"19462","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","%_wp_old_date%":"2024-02-06","%_yoast_wpseo_opengraph-description%":"Ontdek Valley of the Gods in de staat Utah. Benieuwd wat je er kunt doen? Tips voor een bezoek aan de Valley of the Gods.","taxonomy=category":"Natuurgebieden","taxonomy=post_tag":"Utah","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""}},"id":19458,"infowindow_disable":false},{"source":"post","title":"Red Rock Canyon State Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Red Rock Canyon State park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/03/red-rock-canyon-rotsformatie-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Red Rock Canyon State Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"37749 Abbott Dr, Cantil, CA 93519, Verenigde Staten","location":{"lat":"35.3843718","city":"Cantil","state":"California","country":"Verenigde Staten","lng":"-117.9623195","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/red-rock-canyon-state-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Red Rock Canyon State Park in Californi\u00eb\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Op zoek naar een onbekend natuurgebied in Californi\u00eb? Bezoek dan het Red Rock Canyon State Park in Californi\u00eb. Je vindt in dit park een combinatie tussen <a href=\"https://www.heyusa.com/nl/joshua-tree-national-park/\">Joshua Tree</a> en <a href=\"https://www.heyusa.com/nl/bryce-canyon-national-park/\">Bryce Canyon National Park</a>. Er zijn enkele mogelijkheden tot wandelen en het is een goede plek om sterren te kijken. Ontdek de woestijnkliffen, rotsformaties, verdwaalde cactussen en hoodoos van het Red Rock Canyon State Park in Californi\u00eb.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]191 kilometer vanaf Los Angeles[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">110 km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-paw\"]38 verschillende soorten zoogdieren[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Een stukje achtergrond van het Red Rock Canyon State Park\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Je vindt Red Rock Canyon State Park in Californi\u00eb in het uiterste zuiden van de <a href=\"https://www.heyusa.com/nl/sierra-nevada-californie/\">Sierra Nevada</a>. Het gebied was ooit de thuisbasis van de Kawaiisu bevolking. Er zijn rotstekeningen en pictogrammen gevonden in het El Paso gebergte. Deze vertegenwoordigen rituele locaties van de voorouders van het Coso volk, de vroege inheemse bewoners. Deze petrogliefen zijn nog steeds te zien in het park. In de vroege jaren '70 dienden de rode rotsformaties als herkenningspunt voor de handelsroutes die door het gebied liepen. Sinds de jaren '30 wordt het park gebruikt als filmlocatie voor <a href=\"https://www.heyusa.com/nl/los-angeles/hollywood/\">Hollywood</a> producties. Denk aan films als Jurassic Park, The Mummy en Beneath the Planet of the Apes die hier opgenomen werden.</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Red Rock Canyon State Park\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Indrukwekkende rode rotsformaties\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"19419\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Hoe kom je bij Red Rock Canyon State Park?\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Je vindt Red Rock Canyon State Park in Cantil, Californi\u00eb (niet te verwarren met Red Rock Canyon National Conservation Area nabij Las Vegas). De dichtstbijzijnde grotere stad is Bakersfield op iets meer dan een uur rijden. <a href=\"https://www.heyusa.com/nl/los-angeles/\">Los Angeles</a> ligt op 2 uur rijden in zuidwestelijke richting. Hierdoor kun je het park bezoeken als een <a href=\"https://www.heyusa.com/nl/dagtrips-los-angeles/\">dagtrip vanuit Los Angeles</a>.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Wat te doen in het Red Rock Canyon State Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In het Red Rock Canyon State Park kun je kennismaken met rode rotsformaties die je vooral kent van de natuurgebieden in Utah. Je vindt er rotstekeningen die achtergelaten zijn door de Kawaiisu indianen en een verlaten oude mijn bij Opal Road Canyon. Om het park te verkennen met de auto, is een 4WD nodig. Hiermee kun je bezienswaardigheden zoals Red Rooster, Red Cliffs, Scenic Cliffs en Hagen Canyon bezoeken. Er zijn mogelijkheden om het park wandelend te verkennen. Daarnaast is het gebied vrij van lichtvervuiling 's nachts, een perfecte plek voor sterrenkijken.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten in het Red Rock Canyon State Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In de buurt van het park zijn alleen 50 primitieve kampeerplekken op Ricardo Campground, ze hebben overigens wel fantastisch uitzicht op de rotsformaties. Er zijn toiletten, water, plekken voor vuur en tafels beschikbaar. Het werkt volgens het principe first-come-first-served. Wil je overnachten in een hotel of andere accommodatie? Dan zijn <a href=\"https://www.booking.com/searchresults.en.html?city=20011460&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=redrockcanyonstateparkbakersfield\" target=\"_blank\" rel=\"noopener\">Bakersfield</a>, <a href=\"https://www.booking.com/searchresults.en.html?city=20015539&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=redrockcanyonstateparkridgecrest\" target=\"_blank\" rel=\"noopener\">Ridgecrest</a> en <a href=\"https://www.booking.com/searchresults.en.html?city=20014181&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=redrockcanyonstateparkla\" target=\"_blank\" rel=\"noopener\">Los Angeles</a> opties.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste periode voor een bezoek aan het Red Rock Canyon State Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De beste periode om het park te bezoeken is de late herfst, winter en vroege lente. In de zomermaanden is het echt te warm om het park te verkennen, de temperaturen liggen tussen de 35-40 graden. In de winter heb je kans op temperaturen rond de 15 graden, de lente en herfst tussen de 20-25 graden.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Wildlife in Red Rock Canyon State Park\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Spot de hagedis\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"19423\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelen in het Red Rock Canyon State Park\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]Het is mogelijk om een aantal wandelingen te maken in het park. Er zijn gemakkelijke wandelingen en wandelingen met iets meer uitdaging. Als je gaat wandelen, ga dan zo vroeg mogelijk op pad, dan ben je op het heetst van de dag weer terug. De routes in het park:\r\n<ul>\r\n \t<li>Red Cliffs Trail | 1,6 kilometer | makkelijk</li>\r\n \t<li>Hagen Canyon | 2 kilometer | makkelijk</li>\r\n \t<li>Ricardo Campground Trail | 2,2 kilometer | makkelijk</li>\r\n \t<li>Nightmare Gulch Loop | 13,8 kilometer | gemiddeld</li>\r\n \t<li>Burro Schmidt's Tunnel | 16,4 kilometer | gemiddeld</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]365 dagen geopend, 24/7[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: lente en herfst[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]$6[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Rode rotsformaties\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Zover je kunt kijken\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"19424\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Meer Californi\u00eb:\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:-18956,-18939,-18932,-17318,-15062,-14907,-14250,-13587,-12504,-11997,-9980,-8742,-4792,-4738,-4714,-4689,-4574,-3208,-3014,-1971,4556,18809,4700,18381\"][/vc_column][/vc_row]","post_title":"Red Rock Canyon State Park","post_link":"https://www.heyusa.com/nl/red-rock-canyon-state-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Red Rock Canyon State park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/03/red-rock-canyon-rotsformatie-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"State Parks","post_tags":"Californi\u00eb","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%inline_featured_image%":"0","%_edit_lock%":"1710861197:2","%_edit_last%":"2","%_thumbnail_id%":"19420","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Red Rock Canyon State Park","%_yoast_wpseo_metadesc%":"In Californi\u00eb vind je het Red Rock Canyon State Park, het park van de rode rotsformaties. Tips voor Red Rock Canyon State Park","%_yoast_wpseo_linkdex%":"77","%_wpgmp_location_address%":"37749 Abbott Dr, Cantil, CA 93519, Verenigde Staten","%_wpgmp_location_city%":"Cantil","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"35.3843718","%_wpgmp_metabox_longitude%":"-117.9623195","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_primary_category%":"170","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1710861298","%_last_editor_used_jetpack%":"classic-editor","%_wp_old_date%":"2023-09-22","%_wp_old_slug%":"saguaro-national-park","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","taxonomy=category":"State Parks","taxonomy=post_tag":"Californi\u00eb","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""}},"id":19413,"infowindow_disable":false},{"source":"post","title":"Bezoek de filmstudio&#8217;s in Los Angeles","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Bezoek de filmstudios in los angeles\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/03/filmstudios-in-los-angeles-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Bezoek de filmstudio&#8217;s in Los Angeles</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Niagara Falls, New York, Verenigde Staten","location":{"lat":"43.0962143","city":"Niagara Falls","state":"New York","country":"Verenigde Staten","lng":"-79.0377388","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/filmstudios-los-angeles/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_column_padding=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"100%\"][ultimate_heading main_heading=\"De filmstudio's in Los Angeles\" main_heading_color=\"#b34a4c\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:50px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Een leuke combi tussen film en attracties\" font_size=\"50\" line_height=\"1\" font_color=\"#000000\"][vc_column_text]\r\n<p style=\"text-align: center;\">Los Angeles en films zijn onafhankelijk met elkaar verbonden. Hollywood staat dan ook synoniem voor <a href=\"https://www.heyusa.com/nl/los-angeles/\">Los Angeles</a>. De meest bekende films afgelopen jaren zijn opgenomen in de verschillende filmstudio's van Los Angeles. Drie bekende filmstudio's in Los Angeles zijn Universal, Warner Bros. en Paramount Pictures, studio's die je allemaal kunt bezoeken. Een aantal tips voor een bezoek aan de filmstudio's in Los Angeles.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row disable_element=\"yes\"][vc_column][fullwidth_row content_width=\"80%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Verschillende themaparken in de filmstudio's\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Ontdek de leuke combinatie tussen filmthema's en attracties\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"19342\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][ultimate_heading main_heading=\"Bezoek de verschillende filmstudio's in Los Angeles\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In Los Angeles heb je de mogelijkheid om verschillende filmstudio's om te bezoeken. We geven je een aantal tips voor een bezoek aan de filmstudio's van Universal, Warner Bros. en Paramount Pictures in Los Angeles.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"12871\" img_size=\"large\" add_caption=\"yes\"][ultimate_heading main_heading=\"Universal Studio's\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][ultimate_heading main_heading=\"Vanaf \u20ac99\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_margin=\"margin-top:5px;margin-bottom:5px;\"][/ultimate_heading][ultimate_heading main_heading=\"Over Universal Studio's\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_column_text]Universal Studio's Hollywood is een van de oudste en beroemdste filmstudio's in Hollywood die nog steeds in gebruik is. De studio is gemaakt om mensen kennis te laten maken met echte Hollywood filmsets door middel van rondleidingen. Het is een van de eerste Universal Studio's themaparken in de wereld. De filmstudio's zijn onderdeel van Universal City waar winkels, hotels en onder andere bioscopen. Universal Studio's werd in 1915 geopend door Duits-Amerikaanse immigrant Carle Laemmle de Taylor Ranch. In eerste instantie voelde het meer als een boerderij dan een filmstudio. Pas in de jaren '60 kwamen de eerste themaparken in Universal en begon het te lijken op de Universal zoals we die nu kennen.[/vc_column_text][ultimate_heading main_heading=\"Ontdek Universal Los Angeles\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_column_text]Met een ticket voor <a href=\"https://www.heyusa.com/nl/universal-studios-hollywood-los-angeles/\">Universal</a> kun je genieten van entertainment. Er zijn themaparken die je kunt bezoeken die allemaal verschillende attracties hebben. Denk hierbij aan Harry Potter World, Jurassic World, Springfield, Transformers of Minion Land. Je kunt ook mee met de <a href=\"https://www.getyourguide.nl/los-angeles-l179/dagticket-voor-universal-studios-hollywood-met-opties-t45453/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=filmstudioslauniversalintekst\" target=\"_blank\" rel=\"noopener\">World Famous Studio Tour</a> waarbij je meer leert over Hollywoodproducties, filmsets te zien krijgt en meer te horen krijgt over de geschiedenis van Hollywood.[/vc_column_text][ultimate_heading main_heading=\"Praktische informatie\" heading_tag=\"div\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_column_text]<b>Duur:</b>\u00a0 Hele dag\r\n<b>Parkeren</b>: 100 Universal City Plaza, Universal City\r\n<b>Tickets van de te voren reserveren:\u00a0</b>Niet per se nodig, je kunt een ticket voor een bepaalde dag van te voren kopen\r\n<strong>Let op:\u00a0</strong> Neem je paspoort mee tijdens een bezoek, de tickets zijn persoonsgebonden[/vc_column_text][ult_buttons btn_title=\"Boek deze tour\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Flos-angeles-l179%2Fdagticket-voor-universal-studios-hollywood-met-opties-t45453%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26cmp%3Dfilmstudioslauniversal|title:Boek%20deze%20rondleiding|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"19344\" img_size=\"large\" add_caption=\"yes\"][ultimate_heading main_heading=\"Warner Bros. Studio's\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][ultimate_heading main_heading=\"Vanaf \u20ac63\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_margin=\"margin-top:5px;margin-bottom:5px;\"][/ultimate_heading][ultimate_heading main_heading=\"Over Warner Bros.\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_column_text]Warner Bros. dat voorheen bekend stond als First National Studio, werd in 1923 opgericht door de 4 broers Warner. Het studio complex wordt al sinds 1926 gebruikt voor het produceren van film en televisie. Een van de bekendste televisieproducties van de afgelopen jaren is de serie Friends dat maar liefst 10 jaar lang gefilmd werd in de studios van Warner Bros. Ook het populaire Full House werd opgenomen in de filmstudio's. Bekende films van de hand van Warner Bros. zijn Annie, The Dark Knight, Spider-Man en La La Land. Er zijn meer dan 30 verschillende binnenstudio's maar ook verschillende buiten studio's. Stage 15 en 16 zijn verreweg het meest gebruikt voor populaire films.[/vc_column_text][ultimate_heading main_heading=\"Warner Bros. Studio Tour\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_column_text]Benieuwd hoe het er op een Hollywood set aan toe gaat? Koop dan een ticket voor de <a href=\"https://www.heyusa.com/nl/warner-bros-los-angeles/\">Warner Bros. Studio Tour Hollywood</a>. Bekijk meer dan 100 hectare aan buitensets die gebruikt werden voor films als Argo en Batman. Ook de tovernaarswereld van Harry Potter komt voorbij. En natuurlijk kan een bezoek aan de set van de serie Friends niet ontbreken. Naast het bezoeken van verschillende film- en tv sets, kom je ook meer te weten over de verschillende fases in het productieproces. Na de tour kun je dineren in het Central Perk Caf\u00e9 of merchandise kopen van je favoriete serie of film.[/vc_column_text][ultimate_heading main_heading=\"Praktische informatie\" heading_tag=\"div\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_column_text]<b>Duur:</b>\u00a0 Tour 1 uur en zelfstandig nog 2 uur\r\n<b>Parkeren</b>: Warner Blvd, Parking Lot op de 5e verdieping\r\n<b>Tickets van de te voren reserveren:\u00a0</b>Ja!\r\n<strong>Tours:\u00a0</strong>Dagelijks\r\n<strong>Let op:</strong> Neem een paspoort mee en er zijn beperkte mogelijkheden tot fotografie en filmen[/vc_column_text][ult_buttons btn_title=\"Boek deze tour\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fwarner-bros-studios-hollywood-l21050%2Flos-angeles-hollywood-rondleiding-door-warner-bros-studio-s-t55864%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26cmp%3Dfilmstudioslawarner|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"19343\" img_size=\"large\" add_caption=\"yes\"][ultimate_heading main_heading=\"Paramount Pictures Studio's\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][ultimate_heading main_heading=\"Vanaf \u20ac65\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_margin=\"margin-top:5px;margin-bottom:5px;\"][/ultimate_heading][ultimate_heading main_heading=\"Over Paramount Pictures\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_column_text]Paramount Pictures heeft een van de grootste filmstudio's ter wereld. Ooit gestart in 1912, is Paramount ook een van de oudste filmmaatschappijen ter wereld. Films als The Godfather, Forrest Gump, Transformers en de Titanic zijn enorme successen van de studio's van Paramount. Vooral Transformers en de Titanic brachten enorm veel geld in het laatje voor Paramount. De film- en televisieproductie maatschappij is de enige van de Big Five filmstudio's (Walt Disney, Universal, Warner Bros. en Sony) die zich binnen de stadsgrenzen van Los Angeles bevindt.[/vc_column_text][ultimate_heading main_heading=\"Paramount Studio Tour\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_column_text]Neem een kijkje achter de schermen bij Paramount Studio's met deze studiotour. Tijdens een 2 uur durende tour ontdek je de eerste grote filmstudio van Hollywood en bezoekt iconische locaties. Met meer dan 110 jaar aan studio-ervaring, valt er genoeg te zien en te leren bij een studiotour. Maak kennis met Hollywood tijdens deze studiotour.[/vc_column_text][ultimate_heading main_heading=\"Praktische informatie\" heading_tag=\"div\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_column_text]<b>Duur:</b>\u00a0 In totaal 2 uur\r\n<b>Parkeren</b>: Visitor Parking Lot A: 643 N Windsor Blvd, Hollywood\r\n<b>Tickets van de te voren reserveren:\u00a0</b>Ja!\r\n<strong>Tours:\u00a0</strong>Dagelijks[/vc_column_text][ult_buttons btn_title=\"Boek deze tour\" btn_link=\"url:https%3A%2F%2Fparamountstudiotour.ventrata.com%2Fen%2Fstudio-tour|title:Boek%20deze%20tour|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"95%\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space][fullwidth_row][vc_custom_heading text=\"Andere interessante artikelen\" font_container=\"tag:div|font_size:65|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"size:4|order_by:date|order:DESC|post_type:post|categories:-63,-62|by_id:16928,12865,14186,5003\"][/vc_column][/vc_row]","post_title":"Bezoek de filmstudio&#8217;s in Los Angeles","post_link":"https://www.heyusa.com/nl/filmstudios-los-angeles/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Bezoek de filmstudios in los angeles\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/03/filmstudios-in-los-angeles-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Los Angeles","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906882917{padding-top: 25px !important;}","%inline_featured_image%":"0","%_edit_last%":"2","%_edit_lock%":"1710931685:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"15","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"19346","%_wpgmp_location_address%":"Niagara Falls, New York, Verenigde Staten","%_wpgmp_location_city%":"Niagara Falls","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"43.0962143","%_wpgmp_metabox_longitude%":"-79.0377388","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"filmstudios los angeles\"]","%_yoast_wpseo_focuskw%":"Bezoek de filmstudio's in Los Angeles","%_yoast_wpseo_metadesc%":"Bezoek de filmstudio's in Los Angeles. Bezoek de filmstudio's vanUniversal, Warner Brothers, Paramount Pictures in Los Angeles","%_yoast_wpseo_linkdex%":"72","%_yoast_wpseo_primary_category%":"52","%_yoast_wpseo_title%":"Bezoek de filmstudio's in Los Angeles","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1710422323","%_last_editor_used_jetpack%":"classic-editor","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","taxonomy=category":"Bezienswaardigheden Los Angeles","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""}},"id":19340,"infowindow_disable":false},{"source":"post","title":"Goblin Valley State Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Goblin Valley State Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/03/three-sisters-Goblin-Valley-State-Park-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Goblin Valley State Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"18630Goblin, Valley Road, Green River, UT 84525, Verenigde Staten","location":{"lat":"38.573697","city":"Green River","state":"Utah","country":"Verenigde Staten","lng":"-110.707109","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/goblin-valley-state-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Goblin Valley State Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een klein, afgelegen en uniek staatspark, dat is Goblin Valley State Park. Duizenden rotsformaties die er uit zien als pannenkoeken of champignons, ook wel goblins genoemd, maken van het park een bezienswaardigheid dat de moeite waard is. Het park is een goede tussenstop wanneer je een roadtrip maakt in Utah. Verken het park via de verschillende wandelroutes en ontdek de mooiste en unieke goblins. Tips voor een bezoek aan Goblins Valley State Park.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]347 kilometer vanaf Salt Lake City[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">40 km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-paw\"]7 verschillende soorten dieren[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"De geschiedenis van Goblin Valley State Park\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Goblin Valley State Park ligt in de San Rafael woestijn. In het gebied is bewijs gevonden van Indiaanse culturen, zoals de Fremont, Paiute en Ute. Er zijn verschillende rotstekeningen gevonden die dit bevestigen. Daarna volgden de cowboys die in het gebied op zoek waren naar vee. Het gebied werd in kaart gebracht door Arthur Chaffin, hij zocht rond 1920 samen met twee metgezellen een route door het gebied, toen ze het uitkijkpunt bereikten waren ze enorm onder de indruk. Ze zagen 5 buttes en een valei met allemaal pannenkoek rotsformaties. In 1949 keerde Chaffin terug naar het gebied dat hij inmiddels omgedoopt had tot de Vallei van de Paddestoelen. Hij bracht dagen door met het fotograferen van de rode rotsen. Ondanks de afgelegen ligging werd al snel een poging gedaan om het gebied te beschermen tegen vandalisme, in 1964 werd het officieel een staatspark.</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Goblin Valley State Park\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"``Vallei van de paddenstoelen``\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"19245\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Hoe kom je bij Goblin Valley State Park?\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het state park ligt op meer dan 300 kilometer van <a href=\"https://www.heyusa.com/nl/wat-te-doen-in-salt-lake-city/\">Salt Lake City</a>. Er liggen niet echt andere grote plekken in de buurt, het wordt vooral omringd door nationale parken en andere natuurgebieden. <a href=\"https://www.heyusa.com/nl/arches-national-park/\">Arches National Park</a>, <a href=\"https://www.heyusa.com/nl/canyonlands-national-park/\">Canyonlands National Park</a> en <a href=\"https://www.heyusa.com/nl/capitol-reef-national-park/\">Capitol Reef National Park</a> liggen alle 3 in de buurt. Je kunt het state park bereiken op de volgende manier, vanaf de I-70 sla je af op Highway 24 en rijd zuidwaarts een kleine 40 kilometer naar de aangegeven afslag naar het park. Vanaf daar volg je nog 19 kilometer de verharde weg naar het park.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Wat te doen in het Goblin Valley State Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De belangrijkste bezienswaardigheid waarom mensen naar Goblin Valley State Park afreizen is het zien van meer dan duizenden goblins. Je kunt het gebied het beste wandelend verkennen. Fotografen kunnen hun hart ophalen, want het park is enorm fotogeniek. Rondom het state park zijn mogelijkheden om te mountainbiken of een ATV te pakken. Er zijn verschillende canyons in de buurt zoals Little Wild Horse Canyon.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten in het Goblin Valley State Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In de buurt van het park bevindt zich een camping waar je kunt overnachten. Reserveren voor de camping is noodzakelijk, ze kunnen voor een periode van vier maanden worden gereserveerd. Kamperen kan vanaf $45. Gedurende het jaar kun je ook overnachten in \u00e9\u00e9n van de 2 yurts. Ze zijn toegankelijk per auto en hebben stapelbedden. Er kunnen in totaal 5 gasten in een yurt. Kussens, dekens en keukenspullen dien je zelf mee te nemen. De dichtstbijzijnde stad is Hanksville op iets meer dan 50 kilometer. Bekijk hier de <a href=\"https://www.booking.com/searchresults.en.html?city=20133222&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=goblinvalleyhanksville\" target=\"_blank\" rel=\"noopener\">mogelijkheden om in Huntsville te overnachten</a>.\u00a0 Iets verder weg, maar met iets meer opties, is de <a href=\"https://www.booking.com/searchresults.en.html?city=20133194&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=goblinvalleygreenriver\" target=\"_blank\" rel=\"noopener\">plek Green River</a>.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste periode voor een bezoek aan het Goblin Valley State Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De beste periode om het park te bezoeken is in lente en herfst. In deze periode zijn de temperaturen het beste. In de winter kan het nog -8/-9 worden en in de zomermaanden tussen de 35 en 40 graden. Plaatselijke overstromingen, bliksem en andere gevaarlijke weersomstandigheden zijn mogelijk. Bekijk daarom altijd de weersvoorspellingen voor je bezoek. Ga je in de zomer of op een warme dag? Het gebied is ruig met weinig faciliteiten, zorg dat je altijd voldoende eten en drinken bij je hebt. Het mooiste moment voor een bezoek aan het park is overigens in de ochtend of laat in de middag, de lichtinval is dan het mooist.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Wandelen in Goblin Valley State Park\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_empty_space height=\"10px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Ontdek het park te voet\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"19246\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelen in het Goblin Valley State Park\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]Het Goblin Valley State Park is een relatief klein state park. Er zijn een drietal trails uitgezet die je kunt lopen in het park. Daarnaast mag je ook van de paden af om te wandelen tussen de Goblins. Loop vooral door naar het einde van het park, hier vind je namelijk de mooiste goblins. De routes in het park:\r\n<ul>\r\n \t<li>Curtis Bench Trail | 3,3 kilometer</li>\r\n \t<li>Carmel Canyon Trail | 2,4 kilometer</li>\r\n \t<li>Entrada Trail | 2 kilometer</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]365 dagen geopend\r\n06.00-22.00 uur geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: lente en herfst[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]$20 voor auto's\r\n$5 voor voetgangers[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Goblins in het Goblin Valley State Park\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_empty_space height=\"10px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Zijn het pannenkoeken of toch champignons?\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"19253\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Meer Utah:\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:-17318,-15062,-14907,-14250,-12504,-11997,-9980,-8742,-4792,-4738,-4714,-4689,-4574,-3208,-3014,-1971,18939,18956,18932,13587\"][/vc_column][/vc_row]","post_title":"Goblin Valley State Park","post_link":"https://www.heyusa.com/nl/goblin-valley-state-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Goblin Valley State Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/03/three-sisters-Goblin-Valley-State-Park-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"State Parks","post_tags":"Californi\u00eb","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%inline_featured_image%":"0","%_edit_lock%":"1709728910:2","%_edit_last%":"2","%_thumbnail_id%":"19244","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Goblin Valley State Park","%_yoast_wpseo_metadesc%":"In Utah vind je het Goblin Valley State Park, het park van de 'mushrooms. Tips voor Goblin Valley State Park.","%_yoast_wpseo_linkdex%":"78","%_wpgmp_location_address%":"18630Goblin, Valley Road, Green River, UT 84525, Verenigde Staten","%_wpgmp_location_city%":"Green River","%_wpgmp_location_state%":"Utah","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.573697","%_wpgmp_metabox_longitude%":"-110.707109","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_primary_category%":"170","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1709728670","%_last_editor_used_jetpack%":"classic-editor","%_wp_old_date%":"2023-09-22","%_wp_old_slug%":"saguaro-national-park","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","taxonomy=category":"State Parks","taxonomy=post_tag":"Californi\u00eb","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""}},"id":19243,"infowindow_disable":false},{"source":"post","title":"Dead Horse Point State Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Dead Horse Point State park Utah\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/11/dead-horse-point-state-park-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Dead Horse Point State Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"UT-313, Moab, UT 84532, Verenigde Staten","location":{"lat":"38.50542669999999","city":"Moab","state":"Utah","country":"Verenigde Staten","lng":"-109.7294241","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/dead-horse-point-state-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Dead Horse Point State Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Dead Horse Point State Park, vooral bekend vanwege een 'bocht' die door het landschap kronkelt. Hoewel <a href=\"https://www.heyusa.com/nl/horseshoe-bend/\">Horseshoe Bend</a> in Amerika een van de populairste 'bochten' wereldwijd is, blijkt er dus nog een prachtige bocht te zijn. Overigens een term dat inmiddels wereldwijd gebruikt wordt, vele plekken die een zelfde soort bocht hebben, worden de Horseshoe Bend van een land of plek genoemd. In Utah vind je dus een tweede Horseshoe Bend. Een stuk minder bekend en daardoor een stukje rustiger. Je blijkt er een prachtig uitzicht te hebben over de Colorado River die 600 meter lager door het landschap kronkelt. Tips voor een bezoek aan het Dead Horse Point State Park.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]51 kilometer van Moab[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">21 km2</span>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"De legende van Dead Horse Point State Park\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De naam Dead Horse klinkt natuurlijk redelijk luguber. Er gaat een legende dat de naam komt uit eind 19e eeuw. Het punt werd gebruikt als vangnet voor wilde mustangs. Cowboys dreven ze naar de smalle landtong waardoor ze 'opgesloten' kwamen te zitten zonder water, dat zich overigens zo'n 600 meter lager bevond. De paarden vonden helaas de dood doordat ze uitgedroogd raakten.[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Zonsopgang en zonsondergang\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"De beste tijd om het park te bezoeken\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"19238\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Hoe kom je bij het Dead Horse Point State Park?\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Je kunt het park makkelijk bereiken vanuit Moab. Rijd ongeveer 15 kilometer noordwest vanaf Moab op US 191. daarna ongeveer 37 kilometer zuidwest op Utah 313. De afstand tot het visitor center vanuit Moab is ongeveer 45 minuten. Daarnaast is goed te combineren met <a href=\"https://www.heyusa.com/nl/canyonlands-national-park/\">Canyonlands National Park</a>.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten in de buurt\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Er zijn 2 mogelijkheden om te kamperen bij Dead Horse Point State Park. Je hebt de Kayenta Campground en sinds 2018 ook de Wingate Campground. De plekken hebben mogelijkheden voor elektriciteit, picknickplekken, toiletten en douches. Een andere mogelijkheid om te overnachten is in 1 van de 9 yurts bij het park. D\u00e9 locatie voor een zonsopkomst en zonsondergang. Je kunt met 6 personen slapen in deze yurts. <a href=\"https://utahstateparks.reserveamerica.com/camping/dead-horse-point-state-park/r/campgroundDetails.do?contractCode=UT&amp;parkId=344161\" target=\"_blank\" rel=\"noopener\">Bekijk hier de yurts</a>. Om iets luxer te overnachten is Moab de beste uitvalsbasis. Hier vind je <a href=\"https://www.booking.com/searchresults.en.html?city=20133603&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=deadhorsepoint\" target=\"_blank\" rel=\"noopener\">vele hotels</a> om te overnachten.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Wat te doen bij het Dead Horse Point State Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Dead Horse Point State Park is een relatief klein park. Hoewel het uitzicht over deze 'Horseshoe Bend' veel goed maakt, zijn er weinig andere dingen om te doen in het park. Er zijn een aantal korte hiking en fiets trails, verschillende andere uitkijkpunten om te bewonderen en je kunt er goed picknicken. Daarnaast is het park een gecertificeerd Dark Sky Park, een perfecte plek om sterren te kijken.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste periode om het Dead Horse Point State Park te bezoeken\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Je kunt Dead Horse Point State Park het hele jaar door bezoeken. Echter kan het in de zomermaanden warm worden in het park. De beste jaargetijde is daarom de lente of herfst. In de wintermaanden heb je kans op temperaturen rond het vriespunt en kan het af en toe sneeuwen. Het populairste moment op de dag om het park te bezoeken is tijdens zonsopkomst en zonsondergang.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Dead Horse Point State Park\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Trails in het park\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"19237\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"19236\" img_size=\"large\" add_caption=\"yes\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]365 dagen per jaar - vanaf 06.00-22.00 uur[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]$20 voor een auto\r\n$10 voor voetgangers[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: lente en herfst[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"75px\"][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ontdek meer natuur in de buurt\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][ultimate_heading main_heading=\"Nog meer Utah\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:40px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:45px;\"][/ultimate_heading][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"25px\"][thb_postbackground style=\"style2\" source=\"by_id:-16192,-16204,-16174,-16126,-15644,-15614,-15580,-1262,-2267,-572,-545,18916,4195,1273,4817\"][/vc_column][/vc_row]","post_title":"Dead Horse Point State Park","post_link":"https://www.heyusa.com/nl/dead-horse-point-state-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Dead Horse Point State park Utah\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/11/dead-horse-point-state-park-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"State Parks","post_tags":"Utah","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}","%inline_featured_image%":"0","%_edit_lock%":"1709711549:2","%_edit_last%":"2","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Dead Horse Point\"]","%_yoast_wpseo_focuskw%":"Dead Horse Point State Park","%_yoast_wpseo_metadesc%":"Ontdek Dead Horse Point State Park in de staat Utah. Benieuwd wat je er kunt doen? Tips voor een bezoek aan de Dead Horse Point State Park.","%_yoast_wpseo_linkdex%":"68","%_wpgmp_location_address%":"UT-313, Moab, UT 84532, Verenigde Staten","%_wpgmp_location_city%":"Moab","%_wpgmp_location_state%":"Utah","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.50542669999999","%_wpgmp_metabox_longitude%":"-109.7294241","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_primary_category%":"170","%_yoast_wpseo_title%":"Dead Horse Point State Park %%page%% %%sep%% %%sitename%%","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1709711241","%_last_editor_used_jetpack%":"classic-editor","%standard-featured-credit%":"","%_thumbnail_id%":"13596","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","%_wp_old_date%":"2024-02-06","taxonomy=category":"State Parks","taxonomy=post_tag":"Utah","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""}},"id":19233,"infowindow_disable":false},{"source":"post","title":"Antelope Island State Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Antelope Island State Park in Utah\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/02/antelope-island-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Antelope Island State Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Antelope Island State Park, Utah, Verenigde Staten","location":{"lat":"41.0051763","state":"Utah","country":"Verenigde Staten","lng":"-112.2545153","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/antelope-island-state-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Antelope Island State Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Utah kent tal van state parks. Veel staan bekend om de rode rotsformaties. Een state park die dat niet heeft in Utah, is Antelope Island State Park. Je vindt het park in de buurt van <a href=\"https://www.heyusa.com/nl/wat-te-doen-in-salt-lake-city/\">Salt Lake City</a> waardoor het een leuke dagtrip is vanuit de stad. Het park maakt onderdeel uit van de Great Salt Lake en heeft een combinatie van natuur en wildlife. Een aantal tips voor een bezoek aan Antelope Island State Park in <a href=\"https://www.heyusa.com/nl/utah/\" target=\"_blank\" rel=\"noopener\">Utah.</a>[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]40 kilometer vanaf Salt Lake City[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">190 km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-paw\"]12 verschillende soorten dieren, waarvan tussen 500-700 bizons[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Het grootste eiland van Great Salt Lake\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Met een oppervlakte van 109 km3 is Antelope Island State Park de grootste van de 10 eilanden die in Great Salt Lake liggen. Bij een lage waterstand wordt Antelope Island een schiereiland. Het gebied was lange tijd particulier bezit door de Mormomen die zich rond 1848 in deze regio vestigden. De grond werd gebruikt voor een ranch. In 1969 kocht de staat het noordelijke deel, in 1981 werd de rest opgekocht. De naam komt overigens <span style=\"font-weight: 400;\">van de eerste ontdekkers die in 1843 antilopen zagen lopen op het eiland.</span></p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Bizon in Antelope Island State Park in Utah\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Veel wildlife in het state park\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"19125\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Hoe kom je bij Antelope Island State Park?\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Je kunt Antelope Island State Park bereiken via Interstate 15. Neem exit 332, rijd daarna naar het westen op Antelope Drive voor ongeveer 11 kilometer naar de entree. Daarna rijd je over de dijk naar het eiland.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Wat te doen in Antelope Island State Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Hoewel Antelope Island State Park niet heel groot is, zijn er een aantal dingen die je er kunt doen. Er zijn niet alleen een aantal hiking trails, je kunt er ook mountainbiken. Daarnaast zijn er mogelijkheden om de kajakken en paddleboarden op het water. Het gebied is een dark sky park, waardoor sterrenkijken ook een goede activiteit is. En natuurlijk is het gebied een goede plek om wildlife te spotten. Antilopes en bizons lopen vrij in het gebied, maar ook dikhoornschapen, coyotes, stekelvarkens, dassen en lynxen leven in het gebied.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten in Antelope Island State Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In het Antelope Island State Park zijn alleen mogelijkheden om te kamperen. Er zijn plekken voor families, kleine groepen en grote groepen. Er zijn faciliteiten op de campings, bijvoorbeeld toiletten en douches zijn er op Bridger Bay Campground. Er wordt aangeraden om te <a href=\"https://utahstateparks.reserveamerica.com/camping/antelope-island-state-park/r/campgroundDetails.do?contractCode=UT&amp;parkId=343031\" target=\"_blank\" rel=\"noopener\">reserveren</a> voorafgaand aan je bezoek. Wil je in een hotel overnachten? Daarvoor kun je het <a href=\"https://www.booking.com/searchresults.en.html?city=20133956&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=antelopeislandstateparksaltlake\" target=\"_blank\" rel=\"noopener\">beste een accommodatie in Salt Lake City kiezen</a>.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reisperiode Antelope Island State Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Antelope Island State Park is het hele jaar door te bezoeken, maar door de hoge concentratie zout zijn er op bepaalde periodes veel vliegen te vinden. Zeker in de warme zomermaanden kun je last hebben van vliegen. Bezoek daarom het park in de vroege lente of in de herfst.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Wandelen in Antelope Island State Park\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Ontdek het park te voet\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"19128\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelen in het Antelope Island State Park\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]Er is 36 kilometer aan hiking en mountainbike trails op Antelope Island. De Frary Peak Trail is de bekendste trail op het eiland.\r\n<ul>\r\n \t<li>Buffalo Point Trail | 1,6 km</li>\r\n \t<li>Frary Peak Trail | 11,1 km</li>\r\n \t<li>Dooly Know Trail | 3,9 km</li>\r\n \t<li>Lake Side Loop Trail | 8,2 km</li>\r\n \t<li>Lady Finger Trail | 0,6 km</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]365 dagen geopend\r\nmaart - oktober 06.00-22.00 uur\r\nnovember - februari 06.00-19.00 uur[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: lente en herfst[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]$15 voor auto's\r\n$3 voor voetgangers[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"De dijk naar Antelope Island State Park\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Ontdek Antelope Island\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"19126\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Meer Utah:\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:-17318,-15062,-14907,-14250,-12504,-11997,-9980,-8742,-4792,-4738,-4714,-4689,-4574,-3208,-3014,-1971,18939,18956,18932,13587\"][/vc_column][/vc_row]","post_title":"Antelope Island State Park","post_link":"https://www.heyusa.com/nl/antelope-island-state-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Antelope Island State Park in Utah\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/02/antelope-island-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"State Parks","post_tags":"Californi\u00eb","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%inline_featured_image%":"0","%_edit_lock%":"1709558729:2","%_edit_last%":"2","%_thumbnail_id%":"19124","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Antelope Island State Park","%_yoast_wpseo_metadesc%":"In Utah vind je het Antelope Island State Park, gelegen in het Great Salt Lake en dicht bij Salt Lake City. Tips voor Antelope Island State Park.","%_yoast_wpseo_linkdex%":"66","%_wpgmp_location_address%":"Antelope Island State Park, Utah, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Utah","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"41.0051763","%_wpgmp_metabox_longitude%":"-112.2545153","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_primary_category%":"170","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1709106129","%_last_editor_used_jetpack%":"classic-editor","%_wp_old_date%":"2023-09-22","%_wp_old_slug%":"saguaro-national-park","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","taxonomy=category":"State Parks","taxonomy=post_tag":"Californi\u00eb","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""}},"id":19123,"infowindow_disable":false},{"source":"post","title":"Coral Pink Sand Dunes State Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Vegetatie Coral Pink Sand Dunes State Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/02/Coral-Pink-Sand-Dunes-State-Park-vegetatie-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Coral Pink Sand Dunes State Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Kanab, Utah 84741, Verenigde Staten","location":{"lat":"37.03773839999999","city":"Kanab","state":"Utah","country":"Verenigde Staten","lng":"-112.7144334","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/coral-pink-sand-dunes-state-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Coral Pink Sand Dunes State Park in Utah\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Als er een staat is met prachtige state parks, dan is het Utah wel. Een daarvan is het Coral Pink Sand Dunes State Park in het uiterste zuiden van de staat. Een park dat doet denken aan de Sahara door de vele zandduinen. De zandduinen van het park hebben een koraalroze kleur dankzij de eroderende Navajo zandsteen. Het park is populair onder quad rijders, maar er zijn ook mogelijkheden om het te voet te verkennen. Een bezoek brengen aan een landschap vol zandduinen in Utah? Dan ben je hier op de juiste plek.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]289 kilometer van Las Vegas[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">14 km2</span>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Ontstaan Coral Pink Sand Dunes\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een groot woestijnlandschap vol zandduinen, zo kun je Coral Pink Sand Dunes State Park het beste omschrijven. Tussen de bergen van Moquith Mountains en Moccasin Mountains is een tunnel gevormd. De zandkorrels vormden een weg door deze smalle bergen. Het tunneleffect zorgt ervoor dat de snelheid van de wind versterkt werd en de korrels omhoog gezogen en meegevoerd werden, ook wel het Venturi Effect genoemd. Na de tunnel is een open vallei te vinden waardoor de kracht van de wind weer afneemt. Zo'n 10.000-15.000 jaar geleden werd op deze manier het state park gevormd. Sinds 1963 is het gebied officieel een state park.[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Met een buggy op de duinen\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Unieke ervaring in het Coral Pink Sand Dunes State Park\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"19113\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Hoe kom je bij het Coral Pink Sand Dunes State Park?\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Je vindt het Coral Pink Sand Dunes State Park in het uiterste zuiden van de staat Utah. De dichtstbijzijnde plek is Kanab. Vanuit Kanab rijd je via State Route 89 naar het noorden. Na ongeveer 12 kilometer ga je linksaf via Hancock Road waarna je na 14 kilometer een t-splitsing tegenkomt. Het park ligt een kleine 4 kilometer verder.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten in de buurt\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Wil je in de buurt van het Coral Pink Sand Dunes State Park overnachten? Dat kan alleen als je aan het kamperen bent. Er zijn twee plekken om te kamperen. Toch liever in een hotel? Dan is Kanab een goede uitvalsbasis met <a href=\"https://www.booking.com/searchresults.en.html?city=20133369&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=coralpinksandduneskanab\" target=\"_blank\" rel=\"noopener\">voldoende accommodaties</a>.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Wat te doen op in het Coral Pink Sand Dunes State Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Coral Pink Sand Dunes State Park is een grote zandvlakte. Toch zijn er een aantal dingen om te doen in het <a href=\"https://www.heyusa.com/nl/state-parks-utah/\">state park in Utah</a>. Zo kun je sandboarden, met een slee naar beneden en is een groot deel van het gebied open voor off-highway voertuigen. De South Boundary Trail is perfect om met een off road voertuig te rijden. Mocht je die niet hebben, dan kun je een <a href=\"https://www.roam-outdoor.com/\" target=\"_blank\" rel=\"noopener\">guided tour boeken</a> door het gebied.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reisperiode om het Coral Pink Sand Dunes State Park te bezoeken\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Coral Pink Sand Dunes State Park is het gehele jaar door te bezoeken. Verbaas je niet, maar er valt veel neerslag in het gebied. Hierdoor groeien er redelijk wat planten in het woestijnlandschap. Ze staan vaak in de maand juni in bloei. Het park is overigens wel alleen te bezoeken gedurende daglicht, gelukkig kun je een zonsopkomst of zonsondergang nog wel mee pakken. Dit zijn namelijk de mooiste momenten om het park te bezoeken.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Planten in het zandlandschap\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Door de neerslag groeit er van alles in Coral Pink Sand Dunes State Park\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"19116\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"19115\" img_size=\"large\" add_caption=\"yes\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]365 dagen per jaar - van zonsopkomst tot zonsondergang[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]$10[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: voorjaar, vroege zomer en najaar[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"75px\"][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ontdek meer natuur in de buurt\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][ultimate_heading main_heading=\"Nog meer Utah\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:40px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:45px;\"][/ultimate_heading][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"25px\"][thb_postbackground style=\"style2\" source=\"by_id:-16192,-16204,-16174,-16126,-15644,-15614,-15580,-1262,-2267,-572,-545,18916,4195,1273,4817\"][/vc_column][/vc_row]","post_title":"Coral Pink Sand Dunes State Park","post_link":"https://www.heyusa.com/nl/coral-pink-sand-dunes-state-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Vegetatie Coral Pink Sand Dunes State Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/02/Coral-Pink-Sand-Dunes-State-Park-vegetatie-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"State Parks","post_tags":"Utah","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}","%inline_featured_image%":"0","%_edit_lock%":"1708517295:2","%_edit_last%":"2","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"State park Utah\"]","%_yoast_wpseo_focuskw%":"Coral Pink Sand Dunes State Park","%_yoast_wpseo_metadesc%":"Ontdek Coral Pink Sand Dunes State Park in de staat Utah. Benieuwd wat je er kunt doen? Tips voor Coral Pink Sand Dunes State Park.","%_yoast_wpseo_linkdex%":"71","%_wpgmp_location_address%":"Kanab, Utah 84741, Verenigde Staten","%_wpgmp_location_city%":"Kanab","%_wpgmp_location_state%":"Utah","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"37.03773839999999","%_wpgmp_metabox_longitude%":"-112.7144334","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_primary_category%":"227","%_yoast_wpseo_title%":"Coral Pink Sand Dunes State Park %%page%% %%sep%% %%sitename%%","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1708517292","%_last_editor_used_jetpack%":"classic-editor","%standard-featured-credit%":"","%_thumbnail_id%":"19114","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","%_wp_old_date%":"2024-02-06","taxonomy=category":"State Parks","taxonomy=post_tag":"Utah","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""}},"id":19111,"infowindow_disable":false},{"source":"post","title":"Bonneville Salt Flats","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Bonneville Salt Flats in Utah\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/02/bonneville-salt-flats-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Bonneville Salt Flats</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Bonneville-zoutvlakte, Utah 84083, Verenigde Staten","location":{"lat":"40.7787454","state":"Utah","country":"Verenigde Staten","lng":"-113.8352043","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/bonneville-salt-flats/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Bonneville Salt Flats\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De Bonneville Salt Flats is een uniek stukje natuur op ongeveer 170 kilometer buiten Salt Lake City in Utah. Het natuurgebied staat bekent om de grote hoeveelheden zout, grote vlakten met alleen maar zout. Het lijkt alsof je naar een besneeuwde ondergrond kijkt, maar het is echt alleen maar zout. Het leuke aan de Bonneville Salt Flats, is dat je er overheen kunt lopen en zelfs met de auto kun je er overheen rijden. Het gebied staat bekend om de vele snelheidsrecords die er verschillende voertuigen gemaakt worden. Bezoek de Bonneville Salt Flats in Utah voor een unieke belevenis.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]170 kilometer van Salt Lake City[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">100 hectare</span>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Racerecords op de Bonneville Salt Flats\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De Bonneville Salt Flats zijn ongeveer 19 kilometer lang en 8 kilometer breed. Op sommige plekken is de korst 1,5 tot 2 meter dik. Het hele gebied bestaat uit 170 miljoen ton zout, hiervan is 90% gewoon keukenzout. Op de vlakten van de Bonneville Salt Flats worden regelmatig snelheidsrecords gebroken. Doordat de vlakten zo vlak zijn, je ziet zelfs de curves van de aarde, kunnen auto's lange stukken rijden zonder obstakels. De korst van de Bonneville Salt Flats houdt de banden koel bij hoge snelheden. Er zijn snelheden gemeten van 1000 kilometer per uur. Het snelheidsrecord op de racefiets staat op naam van een Nederland. Fred Rompelberg reed met een snelheid van 268,831 op de vlakten in 1995. Ook bij de dames staat het (on)offici\u00eble record op naam van een Nederlandse sinds 2016.[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Racen op de Bonneville Salt Flats\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Vele snelheidsrecords worden hier gevestigd\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"18948\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Hoe kom je bij Bonneville Salt Flats?\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Je kunt de Bonneville Salt Flats bereiken vanaf Exit 4 op de Interstate 80. Je rijdt dan noordwaarts, volgt de Speedway borden en de Leppy Pass Road. Wanneer er water op de vlakten ligt, kun je er beter niet op rijden. Er is kans dat je vast komt te zitten, iets dat je liever niet wilt met een <a href=\"https://www.heyusa.com/nl/auto-huren-in-amerika/\">huurauto in Amerika</a>. Parkeren kan op een van de restarea's waar je een wit gebouw ziet met toiletten.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten in de buurt\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De Bonneville Salt Flats liggen op iets meer dan 170 kilometer vanaf Salt Lake City. Een dagtrip vanuit de stad is mogelijk, maar je houd weinig tijd over om het natuurgebied te bekijken. Je kunt dus overnachten in <a href=\"https://www.booking.com/searchresults.en.html?city=20133956&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=Bonnevillesaltflatssaltlake\" target=\"_blank\" rel=\"noopener\">Salt Lake City</a>, maar wil je dichterbij overnachten? Dan is Wendover een optie. Je vindt hier niet per se speciale hotels, maar veelal de <a href=\"https://www.booking.com/searchresults.en.html?city=20134361&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=Bonnevillesaltflatswendover\" target=\"_blank\" rel=\"noopener\">standaard hotelketens</a>.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Wat te doen op de Bonneville Salt Flats\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Wanneer je de Bonneville Salt Flats bezoekt heb je sowieso al een unieke ervaring, staan op een grondoppervlak dat ooit een meer was en nu bestaat uit zout. Met de auto kun je over de zoutvlaktes rijden en snelheden halen. Je kunt op de zoutvlakten prachtige foto's maken. Zeker wanneer er plassen liggen, is de reflectie enorm mooi. Daarnaast zijn de zoutvlakten een goede plek voor het kijken van sterren. En niet te vergeten, wil je echte snelheden zien? Bezoek dan het gebied tijdens een van de race-events die er gehouden worden.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reisperiode om de Bonneville Salt Flats te bezoeken\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Je kunt de Bonneville Salt Flats het gehele jaar bezoeken. Houd er wel rekening mee dat er in de zomer en herfst vaak <a href=\"https://www.blm.gov/visit/bonneville-salt-flats\" target=\"_blank\" rel=\"noopener\">race events</a> worden gehouden. Van juni tot en met augustus is het het droogte seizoen en heb je grote kans om met de auto te rijden op de zoutvlakten. Wanneer er water op ligt, heb je kans om vast te zitten. Tussen september en november valt de meeste regen. In deze periode heb je wel weer de kans mooie foto's te maken met reflectie van het water. In de zomermaanden kan het warm worden, er is geen schaduw en de zon is fel door de reflectie.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Water op de zoutvlakten\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Laat de auto staan om de mooiste foto's te maken\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"18945\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"18947\" img_size=\"large\" add_caption=\"yes\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]365 dagen per jaar - vanaf 8.00 uur tot zonsondergang[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]Gratis[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: juni - augustus[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"75px\"][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ontdek meer natuur in de buurt\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][ultimate_heading main_heading=\"Nog meer Utah\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:40px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:45px;\"][/ultimate_heading][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"25px\"][thb_postbackground style=\"style2\" source=\"by_id:-16192,-16204,-16174,-16126,-15644,-15614,-15580,-1262,-2267,-572,-545,18916,4195,1273,4817\"][/vc_column][/vc_row]","post_title":"Bonneville Salt Flats","post_link":"https://www.heyusa.com/nl/bonneville-salt-flats/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Bonneville Salt Flats in Utah\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/02/bonneville-salt-flats-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Natuurgebieden","post_tags":"Utah","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}","%inline_featured_image%":"0","%_edit_lock%":"1708008157:2","%_edit_last%":"2","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Bonneville Salt Flats Utah\"]","%_yoast_wpseo_focuskw%":"Bonneville Salt Flats","%_yoast_wpseo_metadesc%":"Ontdek Bonneville Salt Flats in de staat Utah. Benieuwd wat je er kunt doen? Tips voor een bezoek aan de Bonneville Salt Flats.","%_yoast_wpseo_linkdex%":"82","%_wpgmp_location_address%":"Bonneville-zoutvlakte, Utah 84083, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Utah","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7787454","%_wpgmp_metabox_longitude%":"-113.8352043","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_primary_category%":"227","%_yoast_wpseo_title%":"Bonneville Salt Flats %%page%% %%sep%% %%sitename%%","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1707295262","%_last_editor_used_jetpack%":"classic-editor","%standard-featured-credit%":"","%_thumbnail_id%":"18946","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","%_wp_old_date%":"2024-02-06","taxonomy=category":"Natuurgebieden","taxonomy=post_tag":"Utah","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""}},"id":18939,"infowindow_disable":false},{"source":"post","title":"Canyonlands National Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Canyonlands National Park\" width=\"300\" height=\"188\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/02/canyonlands-national-park-300x188.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Canyonlands National Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Utah, Verenigde Staten","location":{"lat":"38.2135733","state":"Utah","country":"Verenigde Staten","lng":"-109.9025345","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/canyonlands-national-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Canyonlands National Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het grootste nationale park van Utah en tegelijkertijd ook het minst bezochte park, dat is Canyonlands National Park. Het park is onderdeel van de 'mighty five' in Utah, 5 van de 'beste' nationale parken in Amerika. Zoals de naam doet vermoeden, een park met veel canyons en rotsformaties. Er lopen twee verharde wegen door het gebied, de Highway 313 naar Island in de Sky en Highway 211 naar The Needles. De rest van het gebied is alleen toegankelijk via off-road wegen waar je een 4x4 voor nodig hebt. Benieuwd naar Canyonlands National Park?[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]389 kilometer vanaf Salt Lake City[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">1300 km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-paw\"]273 verschillende soorten dieren[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"De drie delen van Canyonlands National Park\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Canyonlands National Park wordt gevormd door verschillende rivieren. De Green River, de Colorado River en de zijrivieren hiervan stromen door het gebied. Hierdoor is Canyonlands opgedeeld in drie delen: The Maze, The Island in de Sky en The Needles. Hoewel de gebieden grotendeels ruig zijn, hebben ze alledrie een eigen karakter. Zo is The Maze het meest ruige gedeelte met veel off-road wegen, staat Island in the Sky bekend om de uitzichten en wordt The Needles gekenmerkt door kleurrijke rotsformaties. Overigens worden de rivieren soms gezien als het vierde deel van het park.</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Mesa Arch\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"De populairste plek van Canyonlands National Park\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"18922\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Handig om te weten\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In Canyonlands National Park lopen veel onverharde wegen waar je alleen met een 4x4 op mag rijden. Zo vind je in het Island in the Sky District de 160 kilometer lange White Rim Road die alleen toegankelijk is voor een 4x4. Overigens heb je ook toestemming nodig om in dit deel te overnachten, de rit duurt namelijk 2 dagen. Een andere route die populair is, is de Shafer Trail. Een route die nog voor het visitor center begint en die direct smalle en steile bochten heeft. Je kunt ook van beide routes een stukje rijden. De meeste off-road routes zijn te vinden in het Maze District. Er rijdt geen shuttle of OV in Canyonlands.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Beste reisperiode Canyonlands National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De beste periode voor een bezoek aan Canyonlands National Park is de lente of herfst. De temperaturen kunnen nogal verschillen in het nationale park. Zo liggen de temperaturen in de zomer overdag tussen de 30-40 graden, de nachten tussen 10-20. Terwijl in de winter de temperaturen overdag tussen 0-10 graden liggen en 's nachts kunnen oplopen tot tussen -10 en -20. Daarom zijn de lente en herfst ideaal voor een bezoek, zeker als je ook wilt wandelen. In de herfst heb je kans op onweersbuien in de middag.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Overnachten in Canyonlands National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Er zijn mogelijkheden om te kamperen in Canyonlands National Park, maar verwacht niet te veel van de voorzieningen op de campgrounds. De eerste plek om te kamperen is Willow Flat in Island in the Sky. Hier zijn 12 plekken en geldt het principe first come, first served. Er is geen water, daarvoor moet je naar het visitor center. De andere is The Needles Campground, hier zijn 26 plekken die <a href=\"http://Recreation.gov\" target=\"_blank\" rel=\"noopener\">gereserveerd</a> kunnen worden van lente tot herfst. Overigens kun je hier ook met een camper staan. Wil je in een hotel overnachten? Dan is Moab de beste keuze. Bekijk hier de <a href=\"https://www.booking.com/searchresults.en.html?city=20133603&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=canyonlandsmoab\" target=\"_blank\" rel=\"noopener\">mogelijkheden om te overnachten in Moab</a>.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Uitzichten in Canyonlands National Park\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Enjoy the view!\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"18926\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Wat te doen in Canyonlands National Park\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_row_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"1.\" heading_tag=\"div\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:95px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:100px;\"][/ultimate_heading][vc_single_image image=\"18919\" img_size=\"large\" add_caption=\"yes\"][vc_custom_heading text=\"Island in the sky\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Island in the Sky is het meest populaire district en het makkelijkst te bezoeken. Je kunt dit deel nog bezoeken via een verharde weg en je vindt er een aantal prachtige bezienswaardigheden:\r\n<ul>\r\n \t<li>Mesa Arch</li>\r\n \t<li>Shafer Canyon Overlook</li>\r\n \t<li>Whale Rock</li>\r\n \t<li>Green River Overlook</li>\r\n \t<li>Grand View Overlook</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"2.\" heading_tag=\"div\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:95px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:100px;\"][/ultimate_heading][vc_single_image image=\"18921\" img_size=\"large\" add_caption=\"yes\"][vc_custom_heading text=\"Needles\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Needles District staat vooral bekend om de kleurrijke rotsformaties. Dit deel wordt vooral bezocht door wandelaars en backpackers die meerdere dagen willen wandelen. Het gebied is deels bereikbaar met de gewone auto, maar ook delen zijn alleen toegankelijk voor een 4x4. Ook in The Needles vind je verschillende bezienswaardigheden:\r\n<ul>\r\n \t<li>Cave Spring</li>\r\n \t<li>Roadside Ruin</li>\r\n \t<li>Big Spring Canyon Overlook</li>\r\n \t<li>Chesler Park</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"3.\" heading_tag=\"div\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:95px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:100px;\"][/ultimate_heading][vc_single_image image=\"18920\" img_size=\"large\" add_caption=\"yes\"][vc_custom_heading text=\"Maze\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het ruigste deel van Canyonlands National Park is The Maze, de naam zegt het al, een doolhof. Je kunt makkelijk verdwalen in het gebied, het is een van de meest onherbergzame delen van Amerika. The Maze wordt vooral bezocht door ervaren backpackers, een 4x4 is noodzakelijk, er zijn geen voorzieningen en je bent echt op jezelf aangewezen. Er zijn zeker hoogtepunten in The Maze om te bezoeken, maar helaas kan dit dus niet door iedereen:\r\n<ul>\r\n \t<li>Chocolate Drops</li>\r\n \t<li>Horseshoe Canyon</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelen in het Canyonlands National Park\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]Wandelen in Canyonlands National Park is zeker mogelijk, mits je goed voorbereid op pad gaat. Een aantal trails die je kunt lopen:\r\n<ul>\r\n \t<li>Mesa Arch | Island in the Sky | 1 km | makkelijk</li>\r\n \t<li>White Rim Overlook | Island in the Sky | 2,9 km | makkelijk</li>\r\n \t<li>Grand View Point | Island in the Sky | 2,9 km | makkelijk</li>\r\n \t<li>Aztec Butte | Island in the Sky | 2,3 km | moderate</li>\r\n \t<li>Roadside Ruin | Needles | 0,5 km | makkelijk/moderate</li>\r\n \t<li>Cave Spring | Needles | 1 km | makkelijk/moderate</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]24/7 en 365 dagen geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: lente en herfst[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]$30 voor een auto | $15 voor een persoon[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Off road in Canyonlands National Park\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Sommige delen zijn alleen toegankelijk met een 4x4\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"18925\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Meer Utah\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:-17318,-15062,-14907,-14250,-12504,-11997,-9980,-8742,-4792,-4738,-4714,-4689,-4574,-3208,-3014,-1971,4195,10033,1273,4817\"][/vc_column][/vc_row]","post_title":"Canyonlands National Park","post_link":"https://www.heyusa.com/nl/canyonlands-national-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Canyonlands National Park\" width=\"300\" height=\"188\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/02/canyonlands-national-park-300x188.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Canyonlands National Park","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%inline_featured_image%":"0","%_edit_lock%":"1707212611:2","%_edit_last%":"2","%_thumbnail_id%":"18924","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Canyonlands National Park","%_yoast_wpseo_metadesc%":"In Utah vind je het Canyonlands National Park, bekend vanwege de canyons en rotsformaties en Mesa Arch. Tips voor een bezoek aan Canyonlands National Park.","%_yoast_wpseo_linkdex%":"77","%_wpgmp_location_address%":"Utah, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Utah","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.2135733","%_wpgmp_metabox_longitude%":"-109.9025345","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%_yoast_wpseo_primary_category%":"241","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1706960849","%_last_editor_used_jetpack%":"classic-editor","%_wp_old_date%":"2023-09-22","%_wp_old_slug%":"saguaro-national-park","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","taxonomy=category":"Canyonlands National Park","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""}},"id":18916,"infowindow_disable":false},{"source":"post","title":"SPYSCAPE spionagemuseum New York","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Spyscape spionagemuseum New York\" width=\"300\" height=\"168\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/01/spyscape-museum-300x168.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">SPYSCAPE spionagemuseum New York</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"928 8th Ave, New York, NY 10019, Verenigde Staten","location":{"lat":"40.7652697","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.9837269","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/spyscape-spionagemuseum-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text]<strong>New York kent tal van leuke musea om te bezoeken. Een daarvan is het interactieve SPYSCAPE spionagemuseum. Ontdek welke spionagerol bij je past tijdens verschillende spionage uitdagingen in de Spy HQ. Of test in Spygames je fysieke en mentale behendigheid. Tips voor een bezoek aan het SPYSCAPE spionagemuseum in New York.</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"926 8th Avenue\"][thb_iconlist icon=\"fas fa-subway\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"57 Street - 7 Avenue | N | Q | R | W\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fspyscape-l89453%2Fnew-york-spyscape-spionnenmuseum-en-avontuur-t233642%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26cmp%3Dspyscapemuseum|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Het museum is niet geschikt voor hele jonge kinderen omdat de voertaal Engels is.\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:100%20light%20regular%3A100%3Anormal\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ontdek de spion in je!\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Het SPYSCAPE spionagemuseum in New York is een interactief museum dat je direct bij binnenkomst al merkt. Via een instructiefilm krijg je te horen wat er van je verwacht wordt in het museum. Het museum is verdeeld in 7 verschillende ruimtes die allemaal een eigen thema hebben. Denk aan inlichtingendiensten of cyberoorlogen. Natuurlijk wordt ook gekeken hoe goed je scoort als spion op alle onderdelen. Via een polsbandje worden je vaardigheden bijgehouden. Na alle testen worden de resultaten geanalyseerd en kom je te weten wat voor type spion je bent.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Spionage\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Kom meer te weten over de verschillende aspecten van spionage\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"18891\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"SPYSCAPE spionagemuseum\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Spy HQ\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">SPYSCAPE HQ heeft 7 verschillende ruimtes: Encryptie, Deception, Surveillance, Hacken, Cyberwarfare, Specials Ops en Intelligence. Allemaal verschillende onderwerpen die te maken hebben met spionage worden uitgelicht in deze ruimtes. Ondertussen kun je als bezoeker je vaardigheden testen door verschillende uitdagingen aan te gaan. In de ruimte Debrief krijg je te horen hoe je het gedaan hebt en welke spionagerol het beste past bij je.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Spygames\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Spygames is een spannende ervaring dat ontwikkeld is met experts van de CIA en Special Ops om je fysieke en mentale behendigheid te testen. Samen met je reisgenoten moet je springen, ontwijken, gooien, klimmen bij allerlei verschillende uitdagingen. Niet alleen leuk om te doen, je vergroot ondertussen ook je persoonlijke vaardigheden en conditie.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Spygames\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Ontdek de spion in je\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"20px\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fspyscape-l89453%2Fnew-york-spyscape-spionnenmuseum-en-avontuur-t233642%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26cmp%3Dspyscapemuseumbanneronder|title:Bestel%20tickets%20voor%20SPYSCAPE|target:_blank\" btn_align=\"ubtn-center\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"18889\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ook leuk in New York City:\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][fullwidth_row][thb_postgrid columns=\"4\" source=\"post_type:post|by_id:1594,1312,408,1559\"][/vc_column][/vc_row]","post_title":"SPYSCAPE spionagemuseum New York","post_link":"https://www.heyusa.com/nl/spyscape-spionagemuseum-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Spyscape spionagemuseum New York\" width=\"300\" height=\"168\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2024/01/spyscape-museum-300x168.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea New York","post_tags":"New York","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1707146785:1","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"16","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-08-31","%inline_featured_image%":"0","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Spyscape\"]","%_yoast_wpseo_focuskw%":"Spyscape spionagemuseum New York","%_yoast_wpseo_metadesc%":"Een leuk en interactief museum in New York is het Spyscape spionagemuseum. Ontdek de spion in jezelf door allerlei opdrachten uit te voeren","%_yoast_wpseo_linkdex%":"72","%_wpgmp_location_address%":"928 8th Ave, New York, NY 10019, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7652697","%_wpgmp_metabox_longitude%":"-73.9837269","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_thumbnail_id%":"18890","%post_via%":"","%_yoast_indexnow_last_ping%":"1706275924","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","%activeer_submenu%":"1","%_activeer_submenu%":"field_6593f521e97c2","%locatie_submenu%":"Selecteer een pagina","%_locatie_submenu%":"field_6593f531e97c3","%selecteer_pagina%":"18453","%_selecteer_pagina%":"field_6593f8be019da","%_yoast_wpseo_primary_category%":"","taxonomy=category":"Musea New York","taxonomy=post_tag":"New York","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":18888,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Sierra Nevada in Californi\u00eb","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sierra Nevada in Californi\u00eb\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/12/sierra-nevada-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Sierra Nevada in Californi\u00eb</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Lake Placid, New York 12946, Verenigde Staten","location":{"lat":"44.2794911","city":"North Elba","state":"New York","country":"Verenigde Staten","lng":"-73.9798713","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/sierra-nevada-californie/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\" content_placement=\"middle\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"85%\"][vc_single_image image=\"18420\" img_size=\"large\" add_caption=\"yes\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][heyusa_heading tag=\"div\" heading=\"Drie Nationale Parken in\" font_size=\"45\" line_height=\"50\" font_color=\"#b34a4c\"][vc_custom_heading text=\"Sierra Nevada in Californi\u00eb\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De Sierra Nevada, ook wel Spaans voor besneeuwde bergketen, in Californi\u00eb omvat een groot deel van de staat. Meer dan 25% van het grondgebied van Californi\u00eb behoort tot de Sierra Nevada, een klein deel van het natuurgebied ligt in de staat Nevada. Het gebied bevat 3 nationale parken, 26 wildernis gebieden, 10 national forests en 2 nationale monumenten. Je vindt de Sierra Nevada tussen Central Valley en Basin and Range Province. Met in totaal 640 kilometer lang en 110 kilometer breed, is de Sierra Nevada in Californi\u00eb een prachtig natuurgebied om te ontdekken en wildlife te zien.[/vc_column_text][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1703674807007{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Lake Aloha in de Sierra Nevada\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Wisselende landschappen in de Sierra Nevada\" font_size=\"55\" line_height=\"60\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"18395\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Ontstaan van de Sierra Nevada\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Meer dan 100 miljoen jaar geleden vormde graniet de diepe ondergrond van dit gebied. Vier miljoen jaar geleden werd de bergketen omhoog geduwd en door een gletsjer kwam het graniet bloot te liggen. Hierdoor ontstonden de unieke bergtoppen van de Sierra Nevada. Het landschap van de Sierra Nevada is gevarieerd met verschillende hoogtes, maar ook met bossen, meren, watervallen en enorme bomen.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Overnachten in de Sierra Nevada\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Aangezien het gebied enorm dat tot de Sierra Nevada behoort enorm groot is, is er een verscheidenheid aan locaties waar je kunt overnachten. Denk aan overnachten in de buurt van <a href=\"https://www.booking.com/searchresults.en.html?city=20016087&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=sierranevadatahoe\" target=\"_blank\" rel=\"noopener\">Lake Tahoe</a>, <a href=\"https://www.booking.com/searchresults.en.html?city=20016971&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=sierranevadayosemite\" target=\"_blank\" rel=\"noopener\">Yosemite National Park</a> of het <a href=\"https://www.booking.com/searchresults.en.html?city=20014154&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=sierranevadalonepine\" target=\"_blank\" rel=\"noopener\">Kings Canyon National Park.</a>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Beste reisperiode Sierra Nevada\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De zomer is de meest populaire periode om de Sierra Nevada te bezoeken. In de winter en in de vroege lente is er kans op sneeuwval, zeker in de hoger gelegen delen, waardoor wegen afgesloten zijn. Zelfs eind mei heb je nog kans op sneeuw. Daarom zijn de maanden juni, juli, augustus en begin september de beste periode om de Sierra Nevada te bezoeken. Toch zijn delen van de Sierra Nevada prima in de winter te bezoeken, denk aan ski mogelijkheden rondom Lake Tahoe bijvoorbeeld.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1703752539995{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Sierra Nevada in Californi\u00eb\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"De perfecte plek voor een roadtrip\" font_size=\"55\" line_height=\"60\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"90\" enable_mobile=\"parallax-enable-mobile\" image=\"18387\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ontdek de Sierra Nevada\" font_size=\"50\" line_height=\"55\" font_color=\"#b34a4c\"][vc_custom_heading text=\"Opvallende kenmerken Sierra Nevada\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"25px\"][vc_row_inner][vc_column_inner width=\"1/4\"][vc_single_image image=\"18384\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"General Sherman\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De General Sherman Tree is een van 's werelds bekendste bomen. De sequoia is beroemd vanwege zijn volume, het is namelijk qua volume de grootste boom ter wereld. Hij is 83 meter hoog, heeft een diameter van 11 meter en een stamvolume van 1487 kubieke meter. Waarschijnlijk is hij zo'n 2300-2700 jaar oud. De General Sherman Tree staat in het Giant Forest, hier staan vijf van de tien grootste bomen ter wereld.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][vc_single_image image=\"4868\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Lake Tahoe\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Lake Tahoe is het grootste bergmeer in Noord Amerika. Het zoetwatermeer is daarnaast ook nog eens het op een na diepste meer van de Verenigde Staten. Het is een van de meest populaire bestemmingen in de regio, zowel in de zomer- als in de wintermaanden. In de zomer staan wandelen, varen en zwemmen centraal, in de winter kun je rondom <a href=\"https://www.heyusa.com/nl/lake-tahoe/\">Lake Tahoe</a> de piste op.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][vc_single_image image=\"18383\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Mount Whitney\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De hoogste berg van de 48 aaneengesloten staten vind je in de Sierra Nevada. Mount Whitney is met 4421 meter het hoogste punt. De westelijke helling van Mount Whitney ligt in het <a href=\"https://www.heyusa.com/nl/sequoia-kings-canyon-national-park/\">Sequoia National Park</a> en de top behoort tot de John Muir Trail die naar Yosemite Valley loopt. Overigens maf om te weten is dat Mount Whitney op slechts 122 kilometer van het laagste punt van Noord Amerika ligt, Badwater in <a href=\"https://www.heyusa.com/nl/death-valley-national-park/\">Death Valley</a>.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][vc_single_image image=\"3197\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Yosemite Valley\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In <a href=\"https://www.heyusa.com/nl/yosemite-national-park-californie/\">Yosemite National Park</a> is de glacier valley Yosemite Valley een van de kenmerken van de Sierra Nevada. Hier kwam 100 miljoen jaar oude graniet naar boven door een verdwenen gletsjer. De Merced River heeft de plaats ingenomen van de gletsjer als waterafvoer. Yosemite Valley is 13 kilometer lang en 1600 meter diep. Daarom heen zijn granieten bergtoppen te vinden zoals Half Dome en El Capitan.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" thb_row_padding=\"true\" thb_column_padding=\"true\" content_placement=\"middle\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][thb_image retina=\"retina_size\" full_width=\"true\" image=\"4841\"][/thb_image][/vc_column][vc_column width=\"1/2\"][vc_row_inner][vc_column_inner width=\"5/6\"][heyusa_heading tag=\"div\" heading=\"Ontdek de Giants\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][vc_custom_heading text=\"Kings Canyon &amp; Sequoia National Park\" font_container=\"tag:h3|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het tweede nationale park van Amerika is <a href=\"https://www.heyusa.com/nl/sequoia-kings-canyon-national-park/\">Sequoia National Park</a>. Het park ligt in het zuidelijke deel van de Sierra Nevada en staat bekend om de sequoia bomen, ook wel reuzenbomen. Sequoia National Park en Kings Canyon National Park worden door de nationale park service als \u00e9\u00e9n park gezien. Samen zijn ze een van de meest ongerepte parken van Amerika. Het grootste deel van het park is alleen te voet te verkennen.[/vc_column_text][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fsequoia-kings-canyon-national-park%2F|title:Kings%20Canyon\" btn_size=\"ubtn-small\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:25px;\" btn_line_height=\"desktop:30px;\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][thb_postbackground source=\"size:1|post_type:post|by_id:-14830,-1619,-667,3014\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1606168875038{background-color: #eaeaea !important;}\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"3178\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Lente &amp; zomer\" main_heading_color=\"#000000\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:35px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">De zomermaanden zijn de populairste maanden om de Sierra Nevada te bezoeken. De wegen zijn (vaak) sneeuwvrij, waardoor alle natuurlijke bezienswaardigheden te bezoeken zijn. Het gebied staat in bloei, de watervallen zijn het mooist en de hiking trails zijn goed begaanbaar. Niet alleen de beste periode om de Sierra Nevada te verkennen, ook zijn er de meeste mensen in het gebied.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"17215\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Winter &amp; herfst\" main_heading_color=\"#000000\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:35px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Waar het grootste deel van de Sierra Nevada onbegaanbaar is in de wintermaanden, is Lake Tahoe juist een populaire bestemming om te bezoeken. Het is \u00e9\u00e9n van de beste <a href=\"https://www.heyusa.com/nl/skien-in-amerika/\">wintersportbestemmingen in Amerika</a>. De meeste skigebieden liggen aan de noordkant van het gebied bij Truckee en Reno. In het zuiden is Heavenly Mountain Resort een groot skigebied.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Kings Canyon National Park\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"E\u00e9n van de 3 nationale parken\" font_size=\"55\" line_height=\"60\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"18396\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelen in de Sierra Nevada\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]Met een natuurgebied van 640 kilometer lang en 110 kilometer zijn er genoeg mogelijkheden tot wandelen. Zeker als je bedenkt dat er 3 nationale parken en 26 wildernis gebieden in de Sierra Nevada liggen. Uitdagende en iconische wandelingen van meer dan 100 kilometers, maar ook wandelingen die voor iedereen geschikt zijn. Ontdek vooral Yosemite National Park, Sequoia en Kings National Park wandelend om de mooiste natuur te zien.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Aanraders om te wandelen\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]\r\n<ul>\r\n \t<li>John Muir Trail | 338 kilometer</li>\r\n \t<li>Pacific Crest Trail | 4286 kilometer</li>\r\n \t<li>Yosemite Falls Trail | 12 kilometer</li>\r\n \t<li>Mount Whitney Trail | 33 kilometer</li>\r\n \t<li>Panorama Trail | 13,5 kilometer</li>\r\n \t<li>Tokopah Falls Trail | 6,5 kilometer</li>\r\n \t<li>Buena Vista Peak | 3 kilometer</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1703752797248{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Waterval in Yosemite National Park\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ontdek de watervallen in de Sierra Nevada\" font_size=\"55\" line_height=\"60\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"90\" enable_mobile=\"parallax-enable-mobile\" image=\"18397\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Roadtrippen in de Sierra Nevada\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]Naast wandelmogelijkheden, zijn er ook genoeg mooie routes om met de auto of camper te rijden in de Sierra Nevada. De bergen van de Sierra Nevada hebben al lang aantrekkingskracht op mensen van over de hele wereld. Tel daarbij op de prachtige blauwe meren, de enorme watervallen en vergezichten om bij weg te dromen, dit is waarom dit deel van Californi\u00eb populair is om te bezoeken.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"De mooiste routes in de Sierra Nevada\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]\r\n<ul>\r\n \t<li>Highway 395</li>\r\n \t<li>Sierra Vista Scenic Byway</li>\r\n \t<li>Tioga Road</li>\r\n \t<li>Gold Country Route</li>\r\n \t<li>Ebbett's Pass</li>\r\n \t<li>Monitor Pass</li>\r\n \t<li>Echo Summit</li>\r\n \t<li>Carson Pass</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][thb_postbackground source=\"post_type:post|by_id:7254\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row]","post_title":"Sierra Nevada in Californi\u00eb","post_link":"https://www.heyusa.com/nl/sierra-nevada-californie/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sierra Nevada in Californi\u00eb\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/12/sierra-nevada-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Natuurgebieden","post_tags":"Californi\u00eb","%_wpb_shortcodes_custom_css%":".vc_custom_1703674807007{padding-top: 25px !important;}.vc_custom_1703752539995{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1606168875038{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1703752797248{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}","%inline_featured_image%":"0","%_edit_last%":"1","%_edit_lock%":"1707229124:1","%_wpb_vc_js_status%":"true","%post-primary-category%":"227","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"18388","%_yoast_wpseo_focuskw%":"Sierra Nevada Californi\u00eb","%_yoast_wpseo_metadesc%":"De Sierra Nevada is een enorm natuurgebied in de staat Californi\u00eb. Benieuwd wat je kunt doen in de Sierra Nevada in Californi\u00eb?","%_yoast_wpseo_linkdex%":"80","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Sierra Nevada\"]","%_wpgmp_location_address%":"Lake Placid, New York 12946, Verenigde Staten","%_wpgmp_location_city%":"North Elba","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"44.2794911","%_wpgmp_metabox_longitude%":"-73.9798713","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"7","%_yoast_wpseo_primary_category%":"227","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1707222929","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","%_wp_old_date%":"2023-12-27","%_yoast_wpseo_opengraph-description%":"De Sierra Nevada is een enorm natuurgebied in de staat Californi\u00eb. Benieuwd wat je kunt doen in de Sierra Nevada in Californi\u00eb?","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","taxonomy=category":"Natuurgebieden","taxonomy=post_tag":"Californi\u00eb","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/parken.png"},"id":18381,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/parken.png","name":"Nationale Parken","id":"7","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Walvissen kijken in Californi\u00eb","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Walvissen kijken in Californi\u00eb\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/12/walvis-californie-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Walvissen kijken in Californi\u00eb</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Sanibel Island, Florida, Verenigde Staten","location":{"lat":"26.4433972","state":"Florida","country":"Verenigde Staten","lng":"-82.1115119","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/walvissen-californie/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner][vc_empty_space height=\"15px\"][ultimate_heading main_heading=\"Walvissen kijken in Californi\u00eb\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_empty_space height=\"15px\"][vc_column_text]\r\n<p style=\"text-align: center;\"><strong>Een van de hoogtepunten van de staat Californi\u00eb is het bekijken van walvissen die in grote aantallen voor de kust van de staat voorkomen. Meer dan 20.000 grijze walvissen zwemmen in de wateren van Californi\u00eb. Soms heb je geluk en kun je ze vanaf de kust al zien, soms het is handiger om een excursie te boeken. Een van de de grote voordelen van walvissen spotten in Californi\u00eb, is dat je het hele jaar door de kans hebt om ze te zien.\r\n</strong></p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"25px\"][vc_empty_space height=\"25px\"][ultimate_heading main_heading=\"De beste locaties om walvissen te kijken in Californi\u00eb\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][vc_empty_space height=\"25px\"][vc_column_text]\r\n<p style=\"text-align: center;\">De migratie van de grijze walvissen van Alaska naar Baja Californi\u00eb zorgt ervoor dat de staat een gewilde plek is om walvissen te zien. Op verschillende plekken in de staat is het mogelijk om zeedieren te spotten. In het noorden is Monterey een goede locatie, de overige plekken bevinden zich meer in het zuiden van Californi\u00eb. Onze tips voor de beste locaties om walvissen te zien in Californi\u00eb.</p>\r\n[/vc_column_text][vc_empty_space height=\"25px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/5\"][ultimate_heading main_heading=\"Monterey Bay\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Een van de beste plekken in Californi\u00eb om walvissen te kijken is Monterey Bay. Je vindt hier voor de kust een anderhalf kilometer diepe onderzeese kloof waardoor walvissen en zeezoogdieren graag hier komen. Je kunt zelfs met een beetje geluk de walvissen langs de kust van de <a href=\"https://www.heyusa.com/nl/big-sur/\">Big Sur</a> al zien. Mocht je dichterbij willen komen, dan zijn er verschillende mogelijkheden voor excursies op het water. Boek een <a href=\"https://www.getyourguide.nl/monterey-l548/monterey-bay-excursie-walvis-spotten-t246507/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=walvissenmonterey\" target=\"_blank\" rel=\"noopener\">vier uur durende excursie</a> om deze machtige beesten van dichtbij te zien.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/5\"][ultimate_heading main_heading=\"Newport Beach\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In de buurt van Los Angeles is Newport Beach de beste plek om walvissen te kijken. In de zomer en herfst heb je kans op blauwe vinvissen en in de winter op grijze walvissen. Andere soorten die je nog tegen kunt komen zijn dwergvinvissen, bultruggen, vele soorten dolfijnen en zeehonden. Hoewel de walvissen soms op enkele honderden meters van de kust komen, kun je de walvissen het beste zien <a href=\"https://www.getyourguide.nl/newport-beach-l95366/newport-beach-cruise-om-walvissen-en-dolfijnen-te-spotten-t29161/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=walvissennewport\" target=\"_blank\" rel=\"noopener\">tijdens een tour</a>.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/5\"][ultimate_heading main_heading=\"San Diego\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">San Diego is de plek waar je het hele jaar door walvissen kunt zien. Net als in Newport zijn de zomer en herfst voor de blauwe vinvissen, de winter en lente voor de grijze walvissen de beste periode. De grijze walvissen migreren in de winter en lente van Alaska naar de lagunes van Californi\u00eb om te kalven. Naast walvissen zijn er ook verschillende dolfijnensoorten die zich in de wateren rondom San Diego ophouden. Met <a href=\"https://www.getyourguide.nl/san-diego-l263/san-diego-walvissen-en-dolfijnen-spotten-t6635/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=walvissensandiego\" target=\"_blank\" rel=\"noopener\">een excursie</a> heb je niet alleen de beste kans om de walvissen en dolfijnen te spotten, maar kom je ondertussen ook meer te weten over de zeedieren en het milieubeleid.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/5\"][ultimate_heading main_heading=\"Santa Barbara\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Stap in Santa Barbara <a href=\"https://www.getyourguide.nl/santa-barbara-l393/santa-barbara-catamarancruise-walvissen-spotten-met-bar-t412666/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=walvissensantabarbara\" target=\"_blank\" rel=\"noopener\">aan boord van een catamaran</a> om op een intieme manier een walvis spot ervaring te hebben. In de winter zijn de wateren van Santa Barbara de thuisbasis van meer dan 30 soorten walvissen en dolfijnen. Veel voorkomend zijn Pacifische grijze walvissen, gewone dolfijnen, Californische zeeleeuwen en gewone zeehonden. Mocht je geluk hebben, dan kun je ook nog orka's, blauwe vinvissen, bultruggen en grienden zien zwemmen.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/5\"][ultimate_heading main_heading=\"Dana Point\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Dana Point is het 'whale watching' mekka van de wereld. Je vindt hier meer dolfijnen per vierkante meter dan waar dan ook in de wereld en je kunt er het hele jaar door blauwe vinvissen, gewone vinvissen, grijze walvissen, bultruggen en dwergvinvissen vinden. Daarnaast heb je kans om af en toe de zeldzame orka's, grienden, potvissen en bruinvissen te zien. Bij Dana Point heb je de kans om het grootste dier te bekijken dat ooit op aarde heeft geleefd: de blauwe vinvis. Walvissen kijken bij Dana Point kan het hele jaar door. Ga mee met een<a href=\"https://www.getyourguide.nl/santa-barbara-l393/santa-barbara-catamarancruise-walvissen-spotten-met-bar-t412666/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=walvissendana\" target=\"_blank\" rel=\"noopener\"> excursie op een catamaranboot met een onderwaterpod</a>, waardoor je de dolfijnen en walvissen kunt zien zwemmen onder water.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"25px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Walvissen kijken in Californi\u00eb\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Hoeveel soorten kun jij afstrepen?\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"18318\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Meer Californi\u00eb\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][fullwidth_row][thb_postgrid columns=\"4\" source=\"post_type:post|by_id:-16507,-16400,-16342,-16174,-15355,-15163,-4725,-1559,9942,18148,9961,18278\"][/vc_column][/vc_row]","post_title":"Walvissen kijken in Californi\u00eb","post_link":"https://www.heyusa.com/nl/walvissen-californie/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Walvissen kijken in Californi\u00eb\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/12/walvis-californie-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Avontuur","post_tags":"Californi\u00eb","%_wpb_shortcodes_custom_css%":".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1702643597:2","%_edit_last%":"2","%_wpb_vc_js_status%":"true","%post-primary-category%":"67","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Walvissen kijken in Californi\u00eb","%_yoast_wpseo_title%":"Walvissen kijken in Californi\u00eb%%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een van de beste plekken om walvissen te zien in Amerika is Californi\u00eb. Wat zijn de beste plekken om walvissen te kijken in Californi\u00eb","%_yoast_wpseo_linkdex%":"75","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"Sanibel Island, Florida, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"26.4433972","%_wpgmp_metabox_longitude%":"-82.1115119","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1702643508","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_primary_category%":"67","%post_via%":"","%_thumbnail_id%":"18315","%standard-featured-credit%":"\u00a9 NPI Productions","taxonomy=category":"Avontuur","taxonomy=post_tag":"Californi\u00eb","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":18305,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"17- Mile Drive in Californi\u00eb","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"17 Mile Drive\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/12/17-mile-drive-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">17- Mile Drive in Californi\u00eb</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"17 Mile Dr, Del Monte Forest, CA, Verenigde Staten","location":{"lat":"36.5727577","city":"Del Monte Forest","state":"California","country":"Verenigde Staten","lng":"-121.948717","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/17-mile-drive/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][vc_empty_space height=\"75px\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"25px\"][vc_empty_space height=\"25px\"][ultimate_heading main_heading=\"17-Mile Drive\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]<strong>E\u00e9n van de mooiste autoroutes in Amerika is de 17-Mile Drive op het schiereiland Monterey. De 17 mijl, ook wel 27 kilometer, lange weg, brengt je naar verschillende uitkijkpunten aan de Stille Oceaan. De 17- Mile Drive ligt tussen Carmel-by-the-Sea en Monterey. Je komt hiermee door een van de meest exclusieve communities van Amerika: Pebble Beach. De beste periode trouwens om de 17-Mile Drive te rijden, is in de lente en de herfst, in de zomer is er vaak mist en in de winter kan er redelijk wat neerslag vallen.\r\n</strong>[/vc_column_text][vc_empty_space height=\"75px\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Pebble Beach\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Uitzicht op de rotsformaties\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"18161\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" thb_row_padding=\"true\" thb_column_padding=\"true\" content_placement=\"middle\"][vc_column width=\"1/2\"][vc_row_inner][vc_column_inner width=\"5/6\"][vc_custom_heading text=\"17-Mile Drive\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" heading=\"Hoe kom je op de 17-Mile Drive\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][vc_column_text]\r\n<p style=\"text-align: left;\">Auto's hebben toegang tot de 17-Mile Drive via \u00e9\u00e9n van de vijf poorten waar je een toegangsprijs dient te betalen, ongeveer $12. Je krijgt hiervoor een kaart met bezienswaardigheden langs de route. Kom je vanuit <a href=\"https://www.heyusa.com/nl/bezienswaardigheden-monterey/\">Monterey</a>? Dan is de ingang bij <a href=\"https://www.heyusa.com/nl/highway-1/\">Highway 1</a> en Highway 68 het handigst om te nemen. Kom je vanuit <a href=\"https://www.heyusa.com/nl/wat-te-doen-carmel-by-the-sea/\">Carmel-by-the-Sea</a>? Dan is de toegangspoort van Carmel gate de makkelijkste. De overige ingangen zijn: Pacific Grove Gate, Country Club Gate en S.F.B. Morse Gate. Overigens zijn motoren niet toegestaan op de 17-Mile Drive. Met een fiets of lopend hoef je geen entree te betalen.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"75px\"][fullwidth_row content_width=\"100%\"][thb_image retina=\"retina_size\" full_width=\"true\" image=\"18162\"][/thb_image][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen op de 17-Mile Drive\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">De 17-Mile Drive wordt niet voor niets een van de mooiste autoroutes genoemd. Rijd je in 1 keer door? Dan ben je ongeveer 20 minuten onderweg. Maar eigenlijk is dat enorm zonde. Onderweg zijn 17 uitzichtpunten aan de oceaan die de moeite waard zijn om te stoppen. We selecteerden 4 plekken om in ieder geval te stoppen, maar er zijn nog veel meer!</p>\r\n[/vc_column_text][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/4\"][ultimate_heading main_heading=\"Bird Rock\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_single_image image=\"18155\" img_size=\"large\" add_caption=\"yes\"][vc_column_text]\r\n<p style=\"text-align: center;\">Voor het zien van wildlife is Bird Rock een goede plek om te stoppen. Tot 1930 was de rots nog bedekt met guano van de pelikaan en de aalscholver dat als mest werd gebruikt. Zeeleeuwen profiteerden van de schoongemaakte rotsen en sindsdien liggen er vaak zeeleeuwen op de rotsen. Tussen november en maart kun je hier grijze walvissen voorbij zien zwemmen.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][ultimate_heading main_heading=\"Lone Cypress\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_single_image image=\"18156\" img_size=\"large\" add_caption=\"yes\"][vc_column_text]\r\n<p style=\"text-align: center;\">De meest bekende boom in de regio: De Lone Cypress. Al meer dan 250 jaar staat deze boom op een rotsachtig voetstuk met uitzicht over de Stille Oceaan. De boom staat helemaal alleen op de rots waardoor het een prachtig gezicht is.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][ultimate_heading main_heading=\"Pescadero Point\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_single_image image=\"18157\" img_size=\"large\" add_caption=\"yes\"][vc_column_text]\r\n<p style=\"text-align: center;\">Bij Pescadero Point zie je een aantal griezelige cipressen staan. Daarnaast is de plek een legendarische surfspot. Met de juiste omstandigheden zijn er golven van 15 meter op deze plek.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][ultimate_heading main_heading=\"Spanish Bay\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_single_image image=\"18158\" img_size=\"large\" add_caption=\"yes\"][vc_column_text]\r\n<p style=\"text-align: center;\">De stop Spanish Bay ligt direct aan het water. In 1769 kampeerden hier Spaanse ontdekkingsreizigers die Monterey Bay probeerden te vinden. Het kostte hen een jaar om Monterey Bay te vinden, dit prachtige strand aan de 17-Mile Drive is naar hun vernoemd.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Golfbaan Pebble Beach\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Een van de vele plekken in de buurt van de 17-Mile Drive om een balletje te slaan\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"17868\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" thb_row_padding=\"true\" thb_column_padding=\"true\" content_placement=\"middle\"][vc_column width=\"1/2\"][vc_empty_space height=\"75px\"][fullwidth_row content_width=\"100%\"][thb_image retina=\"retina_size\" full_width=\"true\" image=\"18162\"][/thb_image][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/2\"][vc_row_inner][vc_column_inner width=\"5/6\"][vc_custom_heading text=\"Restaurant tips 17-Mile Drive\" font_container=\"tag:h3|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" heading=\"Ontdek de keuken aan de 17-Mile Drive\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][vc_column_text]\r\n<p style=\"text-align: left;\">De omgeving van de 17-Mile Drive staat bekend als redelijk chique. Op zich hoeft het niet per se duur te zijn wanneer je hier wat wilt eten. Koop wat eten in een supermarkt of haal een broodje onderweg en ga zitten aan een van de vele picknicktafels tussen Point Joe en Seal Rock. Wil je wel graag uit eten en maakt het budget niet uit? Ga dan uit eten bij de Lodge at Pebble Beach, Roy's at Pebble Beach of Stillwater Bar &amp; Grill. Iets goedkopere opties zijn Sticks en Red House Caf\u00e9.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1689956280731{padding-top: 50px !important;padding-bottom: 50px !important;background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2021/08/all-day-usa-background.gif?id=8408) !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][heyusa_heading tag=\"div\" heading=\"Handige info van de redactie\" font_size=\"43\" line_height=\"45\" font_color=\"#b34a4c\"][vc_custom_heading text=\"Overnachten in de buurt van de 17-Mile Drive\" font_container=\"tag:h3|font_size:25|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][vc_row_inner box_shadow=\"large-shadow\" css=\".vc_custom_1689955486087{background-color: #ffffff !important;border-radius: 10px !important;}\"][vc_column_inner][vc_empty_space height=\"25px\"][ultimate_icon_list icon_size=\"65\" icon_margin=\"10\"][ultimate_icon_list_item icon_type=\"custom\" icon_img=\"id^16758|url^https://www.heyusa.com/nl/wp-content/uploads/2023/07/heyusa-expert-tip.png|caption^Hey!USA Expert Tip over reizen naar Amerika|alt^Hey!USA Expert Tip over reizen naar Amerika|title^Hey!USA Expert Tip over reizen naar Amerika|description^Hey!USA Expert Tip over reizen naar Amerika\" content_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" content_font_size=\"desktop:25px;\" content_font_color=\"#282828\"]Hey!USA\r\npersoonlijke tips:[/ultimate_icon_list_item][/ultimate_icon_list][vc_column_text]Hoewel je de 17-Mile Drive in 20 minuten kunt rijden, is het aan te raden om de tijd te nemen voor de bezienswaardigheden in dit deel van Californi\u00eb. Een aantal hotel tips in de buurt van de 17-Mile Drive:\r\n<ul>\r\n \t<li>The Hideaway - op slechts een kilometer van het strand</li>\r\n \t<li>Inn at Spanish Bay - ideaal voor als je ook een balletje wil slaan, maar ook een knus hotel dat uitkijkt over Spanish Bay</li>\r\n \t<li>Casa Palermo - dicht bij Pebble Beach</li>\r\n \t<li>Lodge at Pebble Beach - niet alleen veel shops en restaurants, je kunt ook overnachten in dit 5 sterren hotel</li>\r\n \t<li><a href=\"https://www.booking.com/hotel/us/coral-oasis-pebble-beach.en.html?aid=7958498&amp;no_rooms=1&amp;group_adults=217mileoasis\" target=\"_blank\" rel=\"noopener\">Coral Oasis</a> - vakantiehuis op 1,5 kilometer van het strand</li>\r\n \t<li><a href=\"https://www.booking.com/hotel/us/la-playa-carmel.en.html?aid=7958498&amp;no_rooms=1&amp;group_adults=217miledriveplaya\" target=\"_blank\" rel=\"noopener\">Playa Hotel in Carmel</a> - op 5 minuten van het strand met eigen buitenzwembad</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ontdek meer Californi\u00eb\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][fullwidth_row][thb_postgrid columns=\"4\" source=\"post_type:post|by_id:-16507,-16400,-16342,-16174,-15355,-15163,-4725,-1559,17863,17699,9942,13513\"][/vc_column][/vc_row]","post_title":"17- Mile Drive in Californi\u00eb","post_link":"https://www.heyusa.com/nl/17-mile-drive/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"17 Mile Drive\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/12/17-mile-drive-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1689956280731{padding-top: 50px !important;padding-bottom: 50px !important;background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2021/08/all-day-usa-background.gif?id=8408) !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}.vc_custom_1689955486087{background-color: #ffffff !important;border-radius: 10px !important;}","%_edit_lock%":"1703320588:2","%_edit_last%":"2","%_wpb_vc_js_status%":"true","%post-primary-category%":"16","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"17-Mile Drive","%_yoast_wpseo_title%":"17-Mile Drive%%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Op het schiereiland Monterey ligt een van de mooiste autoroutes lang verschillende de bezienswaardigheden: de 17-Mile Drive. Tips voor de 17-Mile Drive.","%_yoast_wpseo_linkdex%":"77","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"17-Mile Drive Californi\u00eb\"]","%_wpgmp_location_address%":"17 Mile Dr, Del Monte Forest, CA, Verenigde Staten","%_wpgmp_location_city%":"Del Monte Forest","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"36.5727577","%_wpgmp_metabox_longitude%":"-121.948717","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1701690761","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_primary_category%":"65","%post_via%":"","%_thumbnail_id%":"18160","%standard-featured-credit%":"","taxonomy=category":"Bezienswaardigheden","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":18148,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Essex House Miami Beach","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Een kamer in het iconische art-deco Essex House hotel in Miami Beach\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/12/essex-house-miami-beach-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Essex House Miami Beach</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1001 Collins Ave, Miami Beach, FL 33139, Verenigde Staten","location":{"lat":"25.7807415","city":"Miami Beach","state":"Florida","country":"Verenigde Staten","lng":"-80.1314785","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/overnachten-miami/essex-house-miami-beach/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Iconisch art-deco hotel\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][ultimate_heading main_heading=\"1001 Collins Avenue, Miami Beach\" heading_tag=\"div\" main_heading_font_family=\"font_family:Oswald|font_call:Oswald\" main_heading_font_size=\"desktop:30px;\" main_heading_line_height=\"desktop:35px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Essex House Miami Beach\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"$$$\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Het iconische art-deco-hotel Essex House in Miami Beach is een zusterverblijf van het Clevelander Hotel, dat aan Ocean Drive gelegen is. Essex House werd in 1938 gebouwd en ontworpen door Henry Hohauser, het is \u00e9\u00e9n van de meest iconische art-deco hotels in het <a href=\"https://www.heyusa.com/nl/art-deco-district-miami/\" target=\"_blank\" rel=\"noopener\">art-deco district</a> van Miami Beach. Alleen al daarom is het een mooie plek om te verblijven. Waar het Clevelander een \u00e9cht partyhotel is met zwembadfeestjes, luide muziek en veel ambiance, kun je in het Essex House je terugtrekken voor rust. De kamers zijn modern ingericht, er hangt knallende kunst aan de muur en in de badkamer vind je badproducten van Rituals.[/vc_column_text][ultimate_heading main_heading=\"Geselecteerd door Hey!USA\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]Essex House in Miami Beach is een betaalbaar hotel in een spectaculaire art-deco omgeving. De klassieke art-deco elementen van het hotel zijn goed bewaard gebleven en mooi gecombineerd met moderne en glamoureuze aankleding. Het hotel zelf heeft weinig faciliteiten, maar daarvoor kun je bij naastgelegen Clevelander terecht. Kortom, een art-deco klassieker waar je kunt verblijven zonder failliet te gaan![/vc_column_text][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fessex-house.nl.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dessexhouse-hotel-page|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"18137,18138,18139,18140,18141,18142,18143,18144,18145,18146\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"18143\" img_size=\"large\" add_caption=\"yes\" style=\"vc_box_shadow_3d\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Je herkent het Essex House aan z'n iconische art-deco verlichting op het dak, dat er al sinds 1938 staat. De boetiek kamers zijn veelal ruim, in zwart-wit met gouden accenten ingericht en voorzien van alles wat je nodig hebt. Zoals een koffiemachine, koelkastje en airco. De sfeer is retro-cool door het behoud van de prachtige art-deco elementen gecombineerd met modern design. Essex House heeft slechts 71 kamers, geen bar, zwembad en restaurant, waardoor je hier heerlijk rustig kunt overnachten.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"\u00c9\u00e9n straat vanaf Ocean Drive\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"Gratis WiFi\"][thb_iconlist icon=\"fas fa-dollar-sign\" list_content=\"Betaalbaar\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Comfortable kamers met Rituals badproducten\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fessex-house.nl.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dessexhouse-hotel-page|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"Essex House Miami Beach","post_link":"https://www.heyusa.com/nl/overnachten-miami/essex-house-miami-beach/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Een kamer in het iconische art-deco Essex House hotel in Miami Beach\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/12/essex-house-miami-beach-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Overnachten in Miami","post_tags":"","%inline_featured_image%":"0","%_edit_lock%":"1702023529:1","%_edit_last%":"1","%_yoast_wpseo_primary_category%":"234","%_thumbnail_id%":"18134","%_hide_featured%":null,"%_wpgmp_location_address%":"1001 Collins Ave, Miami Beach, FL 33139, Verenigde Staten","%_wpgmp_location_city%":"Miami Beach","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.7807415","%_wpgmp_metabox_longitude%":"-80.1314785","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"13\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%post-primary-category%":"auto","%featured_image_override%":"off","%standard-featured-credit%":"Essex House Miami Beach","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_focuskw%":"Essex House Miami Beach","%_yoast_wpseo_metadesc%":"Glitter, glamour \u00e9n celebrities spotten in dit legendarische Miami Beach resort. Vooral de zwembadfeestjes zijn populair in het Fontainebleau!","%_yoast_wpseo_linkdex%":"68","%post_source%":[{"title":"Fotografie: Essex House Miami Beach","post_source_url":"https://www.essexhotel.com"}],"%_yoast_indexnow_last_ping%":"1701616330","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Overnachten in Miami","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png"},"id":18133,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png","name":"Hotels","id":"13","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Fontainebleau Miami","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Een kamer met zeezicht in het beroemde Fontainebleau resort in Miami Beach\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/12/fontainebleau-miami-beach-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Fontainebleau Miami</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"4441 Collins Ave, Miami Beach, FL 33140, Verenigde Staten","location":{"lat":"25.8177677","city":"Miami Beach","state":"Florida","country":"Verenigde Staten","lng":"-80.12245829999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/overnachten-miami/fontainebleau-miami/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Celebrity resort in Miami\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][ultimate_heading main_heading=\"4441 Collins Avenue, Miami Beach\" heading_tag=\"div\" main_heading_font_family=\"font_family:Oswald|font_call:Oswald\" main_heading_font_size=\"desktop:30px;\" main_heading_line_height=\"desktop:35px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Fontainebleau Miami Beach\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"$$$$\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Het Fontainebleau in Miami Beach is een legendarisch celebrity resort waar wereldberoemde celebrities als Lady Gaga, Kim Kardashian en zelfs Elvis Presley verbleven. Dit levendige, iconische hotel in Mid Beach werd in de jaren '50 ontworpen door architect Morris Lapidus en bestaat uit meerdere gebouwen en torens. Vooral het zwembad is legendarisch vanwege de vele feestjes en pompende beats. Het resort diende als locatie voor talloze iconische films en tv-shows, waaronder The Bodyguard met Whitney Houston en Kevin Costner. Het heeft bovendien een reputatie opgebouwd als hotspot voor beroemdheden. De wereldberoemde poolparty's en nachtclubs van het resort trekken regelmatig beroemdheden aan, waardoor het Fontainebleau Resort d\u00e9 plek is om je favoriete sterren tegen te komen.[/vc_column_text][ultimate_heading main_heading=\"Geselecteerd door Hey!USA\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]Het Fontainebleau is absoluut een klassieker in Miami Beach. Het resort is gigantisch, heeft meerdere restaurants, zwembaden, nachtclubs en een vintage-chique stijl met veel wit. Het hotel ligt direct aan het strand, waardoor je de beats van het beroemde zwembad al van ver kunt horen als je een wandeling maakt over de Miami Beach Boardwalk. Zeker voor jongeren is dit d\u00e9 'place to be'.[/vc_column_text][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Ffontainebleau-resort.nl.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dfontainebleau-hotel-page|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"18124,18125,18126,18127,18128,18129,18130,18131,18120\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"18129\" img_size=\"large\" add_caption=\"yes\" style=\"vc_box_shadow_3d\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Het Fontainebleau in Miami Beach is vooral herkenbaar aan het hotel in de halve boog, uitkijkend op het grote zwembad. In de Tr\u00e9sor toren en de Sorrento toren bevinden zich voornamelijk suites en appartementen. Het resort is modern, luxueus en heeft meerdere restaurants, waaronder een filiaal van het beroemde Hakkasan. De nachtclubs zijn populair bij de locals \u00e9n celebrities in in BleauLive treden regelmatig grote sterren op, zoals Jennifer Lopez. Lig je liever aan het strand? Fontainebleau ligt letterlijk aan Miami Beach met een priv\u00e9 gedeelte voor hotelgasten.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Legendarisch hotel in Mid Beach Miami\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"Gratis WiFi\"][thb_iconlist icon=\"fas fa-utensils\" list_content=\"Meerdere restaurants\"][thb_iconlist icon=\"fas fa-glass-cheers\" list_content=\"Meerdere bars en nachtclubs\"][thb_iconlist icon=\"fas fa-dollar-sign\" list_content=\"Topsegment hotel\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Prachtige kamers met zeezicht\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Ffontainebleau-resort.nl.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dfontainebleau-hotel-page|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"Fontainebleau Miami","post_link":"https://www.heyusa.com/nl/overnachten-miami/fontainebleau-miami/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Een kamer met zeezicht in het beroemde Fontainebleau resort in Miami Beach\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/12/fontainebleau-miami-beach-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Overnachten in Miami","post_tags":"","%inline_featured_image%":"0","%_edit_lock%":"1701613669:1","%_edit_last%":"1","%_yoast_wpseo_primary_category%":"234","%_thumbnail_id%":"18120","%_hide_featured%":null,"%_wpgmp_location_address%":"4441 Collins Ave, Miami Beach, FL 33140, Verenigde Staten","%_wpgmp_location_city%":"Miami Beach","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.8177677","%_wpgmp_metabox_longitude%":"-80.12245829999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"13\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%post-primary-category%":"auto","%featured_image_override%":"off","%standard-featured-credit%":"Fontainebleau Miami Beach","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_focuskw%":"Fontainebleau Miami Beach","%_yoast_wpseo_metadesc%":"Glitter, glamour \u00e9n celebrities spotten in dit legendarische Miami Beach resort. Vooral de zwembadfeestjes zijn populair in het Fontainebleau!","%_yoast_wpseo_linkdex%":"63","%post_source%":[{"title":"Fotografie: Fontainebleau Miami Beach","post_source_url":"https://www.fontainebleau.com"}],"%_yoast_indexnow_last_ping%":"1701613654","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Overnachten in Miami","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png"},"id":18119,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png","name":"Hotels","id":"13","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Life House Little Havana","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Life House hotel in de wijk Little Havana in Miami\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/12/life-house-hotel-little-havana-miami-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Life House Little Havana</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"528 SW 9th Ave, Miami, FL 33130, Verenigde Staten","location":{"lat":"25.768287","city":"Miami","state":"Florida","country":"Verenigde Staten","lng":"-80.2093543","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/overnachten-miami/life-house-little-havana/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Life House Hotel\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][ultimate_heading main_heading=\"528 SW 9th Avenue, Little Havana Miami\" heading_tag=\"div\" main_heading_font_family=\"font_family:Oswald|font_call:Oswald\" main_heading_font_size=\"desktop:30px;\" main_heading_line_height=\"desktop:35px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Life House Hoyel in Little Havana, Miami\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"$$$$\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Op slechts twee straten van het gezellige Calle Ocho (8th Street) kom je deze parel tegen. Verblijven in Life House Little Havana in Miami is alsof je op reis bent in Cuba. Little Havana is het kleurrijke centrum van de Spaans Cubaanse cultuur in Miami. Het gebied is bezaaid met Latijns-ge\u00efnspireerde caf\u00e9s, restaurants en Cubaanse sigarenwinkels. Life House ziet er zelf dan ook uit alsof je in een Cubaanse villa verblijft. Terracotta, donkergroen en veel hout geven het hotel een vintage Cubaanse sfeer. De weelderige 'courtyard' met planten en tapijten en rieten stoelen doen je geloven dat je niet in Miami bent.[/vc_column_text][ultimate_heading main_heading=\"Geselecteerd door Hey!USA\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]Dit bijzondere hotel is niet enkel een aanrader vanwege de locatie in Little Havana, het hotel zelf is prachtig en tot in de kleinste details ontworpen in een retro Cubaanse stijl. De sfeer in de kamers is warm, met donker hout, bedlinnen van 'Revival New York' en producten van 'Le Labo'. Bijzonder is de 'Modern Double' kamer waar je met een vriend of vriendin kunt logeren in een vide-stapelbed met vaste trap. Alle kamers hebben prachtige houten vloeren, een mooie badkamer met moza\u00efek tegels en gouden kranen. Kortom: dit is \u00e9cht een #wow hotel in een bijzondere wijk. Ideaal voor als je 'off the beaten path' wilt in Miami.[/vc_column_text][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Flife-house-little-havana.nl.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dlife-house-hotel-page|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"18106,18107,18108,18109,18110,18111,18112,18113,18114,18115,18100\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"18111\" img_size=\"large\" add_caption=\"yes\" style=\"vc_box_shadow_3d\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Life House bevindt zich in de kleurrijke wijk Little Havana in Miami. Deze wijk staat bekend om zijn Cubaanse invloed met talloze Cubaanse restaurants, winkels, sigarenwinkels en Latino vibes. Het hotel heeft verschillende hotelkamers uiteenlopend van Kingsize tot Suite en kamers met vide-stapelbedden. Er is geen zwembad aanwezig, maar zonnen kan wel op de rooftop. De rooftopbar 'Terras' is een populaire plek voor een hapje en een Mojito met spectaculair uitzicht op de skyline van Miami.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Bijzondere locatie in Little Havana\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"Gratis WiFi\"][thb_iconlist icon=\"fas fa-utensils\" list_content=\"Rooftop 'Terras' met restaurant en bar\"][thb_iconlist icon=\"fas fa-dollar-sign\" list_content=\"Niet goedkoop maar uniek\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Comfortabele bedden\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Flife-house-little-havana.nl.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dlife-house-hotel-page|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"Life House Little Havana","post_link":"https://www.heyusa.com/nl/overnachten-miami/life-house-little-havana/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Life House hotel in de wijk Little Havana in Miami\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/12/life-house-hotel-little-havana-miami-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Overnachten in Miami","post_tags":"","%inline_featured_image%":"0","%_edit_lock%":"1701613596:1","%_edit_last%":"1","%_yoast_wpseo_primary_category%":"234","%_thumbnail_id%":"18100","%_hide_featured%":null,"%_wpgmp_location_address%":"528 SW 9th Ave, Miami, FL 33130, Verenigde Staten","%_wpgmp_location_city%":"Miami","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.768287","%_wpgmp_metabox_longitude%":"-80.2093543","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"13\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%post-primary-category%":"auto","%featured_image_override%":"off","%standard-featured-credit%":"Life House Little Havana","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_focuskw%":"Life House Little Havana","%_yoast_wpseo_metadesc%":"Life House Hotel ligt in de kleurrijke Cubaanse wijk Little Havana in Miami. Dit prachtige boetiek hotel heeft Cubaanse sferen \u00e9n een rooftop!","%_yoast_wpseo_linkdex%":"74","%post_source%":[{"title":"Fotografie: Life House Little Havana","post_source_url":"https://www.lifehousehotels.com/hotels/miami/little-havana"}],"%_yoast_indexnow_last_ping%":"1701613691","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Overnachten in Miami","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png"},"id":18099,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png","name":"Hotels","id":"13","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Kimpton Epic Miami","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Het Kimpton Epic Hotel in Downtown Miami\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/12/kimpton-epic-hotel-miami-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Kimpton Epic Miami</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"270 Biscayne Blvd Way, Miami, FL 33131, Verenigde Staten","location":{"lat":"25.7707204","city":"Miami","state":"Florida","country":"Verenigde Staten","lng":"-80.1891848","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/overnachten-miami/kimpton-epic-miami/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Miami Glamour Hotel\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][ultimate_heading main_heading=\"270 Biscayne Boulevard Way, Downtown Miami\" heading_tag=\"div\" main_heading_font_family=\"font_family:Oswald|font_call:Oswald\" main_heading_font_size=\"desktop:30px;\" main_heading_line_height=\"desktop:35px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Kimpton Epic Hotel Downtown Miami\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"$$$$\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Het Kimpton Epic Hotel in Downtown Miami is een \u00e9cht glamour hotel in een 183 meter hoge toren. De 54 etages kijken uit over de baai van Biscayne en in de verte kun je zelfs de haven van Miami en Miami Beach zien liggen. Het Kimpton Epic heeft 400 kamers waarvan de meeste een priv\u00e9-balkon hebben waar je van het adembenemende uitzicht kunt genieten. Je kunt niet in \u00e9\u00e9n maar twee zwembaden verkoelen op de 16e verdieping \u00f3f een cocktail drinken in Area 31, de rooftop van het Kimpton Epic Hotel.[/vc_column_text][ultimate_heading main_heading=\"Geselecteerd door Hey!USA\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]Verblijven in Downtown Miami is een hele andere beleving dan in Miami Beach. De stad Miami heeft verschillende wolkenkrabbers en het Kimpton Epic Hotel is daar \u00e9\u00e9n van. Ondanks het formaat van het hotel, voelt het niet alsof je in een massahotel verblijft. Een grote pluspunt zijn de kamers met priv\u00e9 balkon waar je niet uitgekeken raakt van het prachtige uitzicht. Kortom, een perfect glamour-hotel voor een paar bruisende dagen in Downtown Miami.[/vc_column_text][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fepic.nl.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dkimpton-epic-hotel-page|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"18082,18083,18084,18085,18086,18087,18088,18089,18076\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"18087\" img_size=\"large\" add_caption=\"yes\" style=\"vc_box_shadow_3d\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Twee zwembaden op de 16e verdieping met spectaculair uitzicht is al bijna een reden om in het Kimpton Epic Hotel te verblijven. Prachtig uitzicht is sowieso \u00e9\u00e9n van de pluspunten van dit 183 meter hoge hotel. Rooftopbar Area 31 is populair bij de locals, de Maison F.P. Journe sigaarlounge heeft slechts plek voor 10 personen die van een sterk drankje houden. Dineren kan bij Area 31 en het Japanse restaurant Zuma. Ontwaken doe je \u00f3\u00f3k met een view op de 16e verdieping.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Bijzondere locatie aan Espa\u00f1ola Way\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"Gratis WiFi\"][thb_iconlist icon=\"fas fa-utensils\" list_content=\"Restaurant en rooftop bar\"][thb_iconlist icon=\"fas fa-glass-cheers\" list_content=\"Area 31 Rooftop\"][thb_iconlist icon=\"fas fa-dollar-sign\" list_content=\"Niet goedkoop maar luxueus\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Comfortabele bedden\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fepic.nl.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dkimpton-epic-hotel-page|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"Kimpton Epic Miami","post_link":"https://www.heyusa.com/nl/overnachten-miami/kimpton-epic-miami/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Het Kimpton Epic Hotel in Downtown Miami\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/12/kimpton-epic-hotel-miami-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Overnachten in Miami","post_tags":"","%inline_featured_image%":"0","%_edit_lock%":"1701516130:1","%_edit_last%":"1","%_yoast_wpseo_primary_category%":"234","%_thumbnail_id%":"18076","%_hide_featured%":null,"%_wpgmp_location_address%":"270 Biscayne Blvd Way, Miami, FL 33131, Verenigde Staten","%_wpgmp_location_city%":"Miami","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.7707204","%_wpgmp_metabox_longitude%":"-80.1891848","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"13\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%post-primary-category%":"auto","%featured_image_override%":"off","%standard-featured-credit%":"Kimpton Epic Hotel","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_focuskw%":"Esm\u00e9 Miami Beach","%_yoast_wpseo_metadesc%":"Glitter, glamour \u00e9n geweldige uitzichten in dit 183 meter hoge hotel. Het Kimpton Epic heeft een populaire rooftopbar \u00e9n twee zwembaden!","%_yoast_wpseo_linkdex%":"51","%post_source%":[{"title":"Fotografie: Kimpton Epic Hotel","post_source_url":"https://www.epichotel.com"}],"%_yoast_indexnow_last_ping%":"1701467017","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Overnachten in Miami","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png"},"id":18075,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png","name":"Hotels","id":"13","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Esm\u00e9 Miami Beach","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Het bijzondere boetiek hotel Esm\u00e9 in Miami Beach\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/12/esme-hotel-miami-beach-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Esm\u00e9 Miami Beach</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1438 Washington Ave, Miami Beach, FL 33139, Verenigde Staten","location":{"lat":"25.78679159999999","city":"Miami Beach","state":"Florida","country":"Verenigde Staten","lng":"-80.1319771","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/overnachten-miami/esme-boetiek-hotel-miami-beach/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Mediterraans Boetiek Hotel in Miami Beach\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][ultimate_heading main_heading=\"1438 Washington Avenue, Miami Beach\" heading_tag=\"div\" main_heading_font_family=\"font_family:Oswald|font_call:Oswald\" main_heading_font_size=\"desktop:30px;\" main_heading_line_height=\"desktop:35px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Esm\u00e9 in Miami Beach\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][ultimate_heading main_heading=\"$$$$\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Alsof je op een oude set beland bent van een James Bond-film met Roger Moore, zo kun je het best het boetiek hotel Esm\u00e9 omschrijven. Dit hotel aan <em>Espa\u00f1ola Way</em><em>\u00a0</em>is tot in de details in een Mediterraanse sfeer uitgevoerd. Van moza\u00efek tot velvet, olijfgroen en donker hout, elke kamer heeft z'n eigen unieke stijl en sfeer. Met een beetje fantasie zie je James Bond in de bar <em>El Sal\u00f3n</em> een Martini bestellen. Wegdromen doe je 's nachts onder linnen van 'Bellino' uit Itali\u00eb en overdag jetset je in het zwembad op de rooftop van het hotel. Lekker eten? Daarvoor moet je niet ver weg te gaan, in Espa\u00f1ola Way kun je terecht voor pasta's, pizza, paella en al het lekkers dat je rond de Mediterraanse zee kunt eten.[/vc_column_text][ultimate_heading main_heading=\"Geselecteerd door Hey!USA\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]Esm\u00e9 in Miami Beach is \u00e9cht zo'n typisch Hey!USA-hotel. Bomvol karakter, sfeer, unieke details en oog voor design. Het is een #bucketlist hotel als je graag verblijft in unieke hotels en absoluut \u00e9\u00e9n van de mooiste boetiek hotels in Miami Beach. In tegenstelling tot de meeste hotels in Miami Beach, die aan Ocean Drive liggen, moet je voor het strand iets verder wandelen, maar dat is slechts vijf minuutjes. Wakker worden kan hier nog traditioneel met een eigen krant, die elke ochtend voor je deur ligt en verse koffie. Voor je gaat slapen komen ze je kamer klaarmaken voor de nacht, deze 'Turndown service' zie je niet meer veel, maar geeft net dat beetje extra.[/vc_column_text][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fesme.nl.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Desme-hotel-page|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"18061,18072,18062,18063,18064,18065,18073,18066,18067,18068,18069,18070,18071\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"18066\" img_size=\"large\" add_caption=\"yes\" style=\"vc_box_shadow_3d\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Vooral de rooftop met het zwembad is een plus van dit hotel. Bijzonder is ook het kleine steegje achter het Esm\u00e9 hotel, alsof je in een Spaanse film zit. Je kunt verblijven in de 'villa' maar er is ook nog de bijzondere 'Casa Matanza' waar je kunt logeren in een suite met de typische 'Capone'-naam. Dat zegt al genoeg over de stijl die je hier kunt verwachten: vintage Al Capones.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Bijzondere locatie aan Espa\u00f1ola Way\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"Gratis WiFi\"][thb_iconlist icon=\"fas fa-utensils\" list_content=\"Restaurant en gezellige bar\"][thb_iconlist icon=\"fas fa-glass-cheers\" list_content=\"Rooftop met bar en zwembad\"][thb_iconlist icon=\"fas fa-dollar-sign\" list_content=\"Niet goedkoop maar een uniek hotel!\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Comfortabele bedden\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fesme.nl.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Desme-hotel-page|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"Esm\u00e9 Miami Beach","post_link":"https://www.heyusa.com/nl/overnachten-miami/esme-boetiek-hotel-miami-beach/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Het bijzondere boetiek hotel Esm\u00e9 in Miami Beach\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/12/esme-hotel-miami-beach-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Overnachten in Miami","post_tags":"","%inline_featured_image%":"0","%_edit_lock%":"1701465888:1","%_edit_last%":"1","%_yoast_wpseo_primary_category%":"234","%_thumbnail_id%":"18057","%_hide_featured%":null,"%_wpgmp_location_address%":"1438 Washington Ave, Miami Beach, FL 33139, Verenigde Staten","%_wpgmp_location_city%":"Miami Beach","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.78679159999999","%_wpgmp_metabox_longitude%":"-80.1319771","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"13\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%post-primary-category%":"auto","%featured_image_override%":"off","%standard-featured-credit%":"Esm\u00e9 Hotel Miami Beach","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_focuskw%":"Esm\u00e9 Miami Beach","%_yoast_wpseo_metadesc%":"Karaktervol boetiek hotel aan het Mediterraanse Espa\u00f1ola Way. Een uniek hotel met een oude James Bond-film sfeer, overnachten als in een film.","%_yoast_wpseo_linkdex%":"60","%post_source%":[{"title":"Fotografie: Esm\u00e9","post_source_url":"https://www.esmehotel.com"}],"%_yoast_indexnow_last_ping%":"1701465942","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Overnachten in Miami","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png"},"id":18052,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png","name":"Hotels","id":"13","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"The Betsy Miami Beach","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Het boutique hotel The Betsy in Miami Beach\" width=\"300\" height=\"196\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/12/The-Betsy-room-miami-beach-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">The Betsy Miami Beach</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1440 Ocean Dr, Miami Beach, FL 33139, Verenigde Staten","location":{"lat":"25.7864772","city":"Miami Beach","state":"Florida","country":"Verenigde Staten","lng":"-80.1298405","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/overnachten-miami/the-betsy-miami-beach/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Prachtig boetiekhotel in Miami Beach\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][ultimate_heading main_heading=\"1440 Ocean Drive, Miami Beach\" heading_tag=\"div\" main_heading_font_family=\"font_family:Oswald|font_call:Oswald\" main_heading_font_size=\"desktop:30px;\" main_heading_line_height=\"desktop:35px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"The Betsy in Miami Beach\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"$$$$\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]The Betsy in Miami Beach is \u00e9cht zo'n typisch #bucketlist hotel waar je wilt overnachten. Gelegen aan de beroemde Ocean Drive en in prachtige art-deco stijl. Het boetiek hotel is tot in de puntjes gestyled wat je het best kunt benoemen als vintage meets beach. De verschillende kamers hebben bovendien elk een eigen stijl. Hier kun je zonder moeite rondlopen met een grote zonnebril, een strandhoed en een kafkajurk als nieuwerwetse jetsetter. Het hotel heeft twee zwembaden, eentje op de rooftop en een zwembad in een knusse binnenplaats. Er is een gezellige bar en Betsy, de Golden Retriever, verwelkomt je met veel liefde en enthousiasme![/vc_column_text][ultimate_heading main_heading=\"Geselecteerd door Hey!USA\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]Wij houden van dit soort hotels. The Betsy in Miami Beach is een hotel met karakter, sfeer en oog voor details. Het is alsof je logeert bij een rijke Amerikaanse met veel smaak in plaats van een typisch hotel. The Betsy ligt bijna aan het einde van de beroemde Ocean Drive en het strand van South Beach is slechts op enkele meters van het hotel verwijderd. De gezellige winkelstraat Lincoln Road en het Mediterraanse Espa\u00f1ola Way liggen \u00f3\u00f3k in de buurt van dit heerlijke hotel.[/vc_column_text][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fthe-betsy.nl.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dthe-betsy-hotel-page|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"18042,18043,18044,18045,18046,18047,18048,18049\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"18043\" img_size=\"large\" add_caption=\"yes\" style=\"vc_box_shadow_3d\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]The Betsy in Miami Beach is niet 'zomaar' een hotel. Natuurlijk mag je hier alle verwennerij verwachten van een luxueus boetiek hotel, maar het leukst is de verbintenis met de buurt. Locals komen hier koffie drinken, plaatselijke kunstenaars mogen in het hotel exposeren en de lobby is altijd gezellig druk. The Betsy heeft twee zwembaden, 'roof decks' waar je kunt zonnen met prachtig zicht op de zee, een fitness, spa en een uitgebreide bibliotheek. Er is regelmatig live muziek in de bar en het restaurant. Kortom, The Betsy is \u00e9cht even genieten.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Toplocatie\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"Gratis WiFi\"][thb_iconlist icon=\"fas fa-utensils\" list_content=\"Restaurant en gezellige bar\"][thb_iconlist icon=\"fas fa-glass-cheers\" list_content=\"Rooftop met bar en zwembad\"][thb_iconlist icon=\"fas fa-dollar-sign\" list_content=\"Niet goedkoop maar absoluut de moeite!\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Comfortabele bedden\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fthe-betsy.nl.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dthe-betsy-hotel-page|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"The Betsy Miami Beach","post_link":"https://www.heyusa.com/nl/overnachten-miami/the-betsy-miami-beach/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Het boutique hotel The Betsy in Miami Beach\" width=\"300\" height=\"196\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/12/The-Betsy-room-miami-beach-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Overnachten in Miami","post_tags":"","%inline_featured_image%":"0","%_edit_lock%":"1701461302:1","%_edit_last%":"1","%_yoast_wpseo_primary_category%":"234","%_thumbnail_id%":"18035","%_hide_featured%":null,"%_wpgmp_location_address%":"1440 Ocean Dr, Miami Beach, FL 33139, Verenigde Staten","%_wpgmp_location_city%":"Miami Beach","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.7864772","%_wpgmp_metabox_longitude%":"-80.1298405","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"13\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%post-primary-category%":"auto","%featured_image_override%":"off","%standard-featured-credit%":"The Betsy Miami Beach","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_focuskw%":"The Betsy Miami Beach","%_yoast_wpseo_metadesc%":"Een prachtig art-deco boutique hotel aan de beroemde Ocean Drive in Miami Beach. Een hotel met B&B-feeling waar honden welkom zijn!","%_yoast_wpseo_linkdex%":"67","%post_source%":[{"title":"Fotografie: The Betsy","post_source_url":"https://www.thebetsyhotel.com"}],"%_yoast_indexnow_last_ping%":"1701460853","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Overnachten in Miami","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png"},"id":18034,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png","name":"Hotels","id":"13","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Yotel Washington DC","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Een Yotel hotelkamer in Washington DC\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/12/Yotel_Premium_King_WashingtonDC-300x200.webp\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Yotel Washington DC</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"415 New Jersey Ave NW, Washington, DC 20001, Verenigde Staten","location":{"lat":"38.89546139999999","city":"Washington","state":"District of Columbia","country":"Verenigde Staten","lng":"-77.0108803","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/overnachten-in-washington-dc/yotel-washington-dc/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Betaalbaar hotel in Washington DC\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][ultimate_heading main_heading=\"415 New Jersey Avenue, Washington DC\" heading_tag=\"div\" main_heading_font_family=\"font_family:Oswald|font_call:Oswald\" main_heading_font_size=\"desktop:30px;\" main_heading_line_height=\"desktop:35px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Yotel Hotel in Washington DC\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"$$$\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Bij <a href=\"https://www.booking.com/hotel/us/the-liason-capitol-hill.nl.html?aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=yotel-hotel-page\" target=\"_blank\" rel=\"noopener\">Yotel in Washington DC</a> draait alles om locatie, locatie, locatie. Het hotel ligt dan ook op wandelafstand van de National Mall. Als je met de trein naar Washington DC reist is Yotel \u00f3\u00f3k heel handig, het ligt namelijk bijna tegenover <a href=\"https://www.heyusa.com/nl/washington-dc/union-station/\" target=\"_blank\" rel=\"noopener\">Union Station</a>. Niet enkel handig vanwege de trein, ook de metro stopt hier. Lange rijen bij het inchecken heb je hier bovendien niet, je kunt namelijk zelf inchecken via een tablet. Yotel in Washington DC is bovendien een budget friendly hotel.[/vc_column_text][ultimate_heading main_heading=\"Geselecteerd door Hey!USA\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]Yotel in Washington DC is door Hey!USA geselecteerd omdat dit hotel dichtbij grote bezienswaardigheden ligt, zoals de National Mall met de vele gratis musea, het Capitool en Union Station. Yotel is een budgetvriendelijk alternatief m\u00e9t vijf sterren faciliteiten. Zoals een rooftop lounge met zwembaden bar. Er is gratis WiFi, koffie en in het restaurant 'Art and Soul' wordt ontbijt geserveerd. Kortom, een ideaal hotel, perfecte locatie, leuk voor je portemonnee en absoluut een aanrader.[/vc_column_text][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fthe-liason-capitol-hill.nl.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dyotel-hotel-page|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"18026,18027,18028,18029,18030,18031\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"18030\" img_size=\"large\" add_caption=\"yes\" style=\"vc_box_shadow_3d\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Yotel in Washington DC ligt op slechts enkele minuten van de National Mall, de vele gratis musea, het Capitool en Union Station. Betaalbaar eten kun je in Chinatown, dat slechts 10 minuten ver wandelen is.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Toplocatie\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"Gratis WiFi\"][thb_iconlist icon=\"fas fa-utensils\" list_content=\"Restaurant\"][thb_iconlist icon=\"fas fa-glass-cheers\" list_content=\"Rooftop lounge met zwembad\"][thb_iconlist icon=\"fas fa-dollar-sign\" list_content=\"Budgetvriendelijk\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Comfortabele bedden\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fthe-liason-capitol-hill.nl.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dyotel-hotel-page|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"Yotel Washington DC","post_link":"https://www.heyusa.com/nl/overnachten-in-washington-dc/yotel-washington-dc/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Een Yotel hotelkamer in Washington DC\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/12/Yotel_Premium_King_WashingtonDC-300x200.webp\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Overnachten in Washington DC","post_tags":"","%inline_featured_image%":"0","%_edit_lock%":"1701455179:1","%_edit_last%":"1","%_yoast_wpseo_primary_category%":"110","%_thumbnail_id%":"18022","%_hide_featured%":null,"%_wpgmp_location_address%":"415 New Jersey Ave NW, Washington, DC 20001, Verenigde Staten","%_wpgmp_location_city%":"Washington","%_wpgmp_location_state%":"District of Columbia","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.89546139999999","%_wpgmp_metabox_longitude%":"-77.0108803","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"13\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%post-primary-category%":"auto","%featured_image_override%":"off","%standard-featured-credit%":"Yotel Washington DC","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_focuskw%":"Yotel Washington DC","%_yoast_wpseo_metadesc%":"Het Yotel in Washington DC is een budgetvriendelijk hotel, dichtbij Union Station, de Mall, de vele musea en het Capitool.","%_yoast_wpseo_linkdex%":"72","%post_source%":[{"title":"Fotografie: Yotel","post_source_url":"https://www.yotel.com"}],"%_yoast_indexnow_last_ping%":"1701447121","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Overnachten in Washington DC","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png"},"id":18021,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png","name":"Hotels","id":"13","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Redwood National Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Redwood National Park\" width=\"300\" height=\"225\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/10/redwoods-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Redwood National Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Californi\u00eb, Verenigde Staten","location":{"lat":"41.4017156","state":"Californi\u00eb","country":"Verenigde Staten","lng":"-124.041711","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/redwood-national-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Redwood National Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]E\u00e9n van de 9 nationale parken in Californi\u00eb is het Redwood National Park. In het park, dat in het noorden van de staat ligt, groeien de enorme kustmammoetbomen. De coastal redwoods zijn de grootste publiekstrekker van het gebied. Met meer dan 100 meter hoogte zijn ze indrukwekkend om te zien. Ze groeien langs de grillige kustlijn waardoor het voelt alsof je nog in een stukje ongerept natuur loopt. Tips voor een bezoek aan het Redwood National Park.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]500 kilometer vanaf San Francisco[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">540 km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-paw\"]200 verschillende soorten dieren[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Redwoods\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Enorme bomen, niet alleen in de lengte, maar ook qua dikte. Officieel worden ze Redwoods genoemd. Ze zijn te onderscheiden in twee soorten, de sequoia's en coastal redwoods. De sequoia's vind je in het <a href=\"https://www.heyusa.com/nl/sequoia-kings-canyon-national-park/\">Sequoia National Park</a>, iets meer landinwaarts in Californi\u00eb. De coastal redwoods, ook wel de kustmammoetbomen genoemd, groeien in het Redwood National Park tot ongeveer 80 meter van de kust. Hier zijn de temperaturen precies goed door het zeeklimaat. Het verschil tussen beide bomen? De sequoia's zijn een stuk dikker en minder hoog dan de redwoods</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Enorme coastal redwoods\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"De hoogste zijn meer dan 100 meter hoog\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"17723\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Facts Redwood National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Redwood National Park werd in 1968 officieel opgericht. Het park vormt \u00e9\u00e9n geheel met drie staatsparken: Del Norte Coast Redwoods State Park, Jedediah Smith Redwoods State Park en Prairie Creek Redwoods State Park. Samen worden ze ook wel Redwood National en State Parks genoemd. De totale oppervlakte beslaat 540 km2 en hierin vind je ongeveer 45% van het nog bestaande bos met coast redwoods. De redwoods in dit deel worden tussen de 500-700 jaar oud en kunnen een hoogte krijgen van meer de 100 meter. De hoogste redwood is de Hyperion met meer dan 115 meter.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Wat te doen in Redwood National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Redwood National Park is een gebied aan de kust met steile kliffen, lagunes, wildlife en enkele wegen die het park doorkruizen. Zo loopt de beroemde <a href=\"https://www.heyusa.com/nl/highway-1/\">Highway 1</a> dwars door het park. De mooiste weg echter is de Newton Drury Scenic Parkway. Vanaf hier starten ook verschillende wandelingen. Volg vanaf hier bijvoorbeeld de Big Tree Wayside die je naar de grootste bomen brengt. Of breng een bezoek aan de Shrine Drive Thru Tree, een door de bliksem getroffen boom waar je doorheen kunt rijden of lopen.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten in Redwood National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Redwood National Park biedt niet veel mogelijkheden om te overnachten. Er zijn 8 basic campgrounds te vinden die je ongeveer een maand van te voren dient te reserveren. Wil je in een hotel overnachten? Bekijk dan de mogelijkheden in <a href=\"https://www.booking.com/searchresults.en.html?city=20012390&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=redwoodsnpcrescent\" target=\"_blank\" rel=\"noopener\">Crescent City</a>, <a href=\"https://www.booking.com/searchresults.en.html?city=20013844&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=redwoodsnpklamath\" target=\"_blank\" rel=\"noopener\">Klamath</a> of <a href=\"https://www.booking.com/searchresults.en.html?city=20014990&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=redwoodsnporick\" target=\"_blank\" rel=\"noopener\">Orick</a>. Hier heb je een aantal opties om te overnachten en zit je dicht bij het Redwoods National Park.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reisperiode Redwood National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het park is in principe het hele jaar te bezoeken. De beste reisperiode voor het Redwood National Park is de lente. De bossen zijn groen, het is er niet te druk en daarbij heb je kans om de rododendron in bloei te zien. De zomer is de meest bezocht periode en is het een stuk drukker in het park. Het najaar is ook een goede periode om het park te bezoeken. De bomen krijgen een klein beetje een herfstkleur en de eerste regen komt vaak pas midden oktober.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Shrine Drive Thru Tree in het Redwood National Park\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Wandel onder door de boom door\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"17721\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelen in het Redwood National Park\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]Aangezien het Redwood National Park 3 state parks bevat, zijn er wandelingen te vinden in verschillende delen van het park. Een aantal tips voor wandelingen in het Redwood National Park:\r\n<ul>\r\n \t<li>Cathedral Trail | easy | 3,5 kilometer | Prairie Creek Redwoods State Park</li>\r\n \t<li>Boy Scout Tree Trail | easy | 8,5 kilometer | Jedediah Smith Redwoods State Park</li>\r\n \t<li>Lady Bird Johnson Grove Trail | easy | 2 kilometer | Redwood National Park</li>\r\n \t<li>Yurok Loop Trail | easy, wel hoogteverschillen | 1,6 kilometer | Del Norte Coast Redwoods State Park</li>\r\n \t<li>Fern Canyon | easy | 1,6 kilometer | Prairie Creek Redwoods State Park</li>\r\n \t<li>Stout Memorial Trail | easy | 1,1 kilometer | Jedediah Smith Redwoods State Park</li>\r\n \t<li>Prairie Creek and Foothill Loop | easy | 4,1 kilometer | Prairie Creek Redwoods State Park</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]24/7 en 365 dagen geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: lente[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]Redwood National Park is gratis, voor de 'day use' van het Prairie Creek Redwoods, Del Norte Redwoods en Jedediah Redwoods State Park zijn er dagpassen.[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Newton Drury Scenic Parkway\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Rijd de scenic drive af voor de mooiste stops\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"17722\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Meer Californi\u00eb\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:-17318,-15062,-14907,-14250,-8742,-4792,-4738,-4714,-4689,-4574,-3208,-1971,3014,11997,12504,9980\"][/vc_column][/vc_row]","post_title":"Redwood National Park","post_link":"https://www.heyusa.com/nl/redwood-national-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Redwood National Park\" width=\"300\" height=\"225\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/10/redwoods-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Redwood National Park","post_tags":"Californi\u00eb","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%inline_featured_image%":"0","%_edit_lock%":"1698299265:2","%_edit_last%":"2","%_thumbnail_id%":"17724","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Redwood National Park","%_yoast_wpseo_metadesc%":"In Californi\u00eb vind je het Redwood National Park, bekend vanwege de enorme kustmammoetbomen. Tips voor een bezoek aan het Redwood National Park.","%_yoast_wpseo_linkdex%":"82","%_wpgmp_location_address%":"Californi\u00eb, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Californi\u00eb","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"41.4017156","%_wpgmp_metabox_longitude%":"-124.041711","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_primary_category%":"237","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1698299281","%_last_editor_used_jetpack%":"classic-editor","%_wp_old_date%":"2023-09-22","%_wp_old_slug%":"saguaro-national-park","taxonomy=category":"Redwood National Park","taxonomy=post_tag":"Californi\u00eb","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""}},"id":17717,"infowindow_disable":false},{"source":"post","title":"Canyon de Chelly National Monument","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Canyon de Chelly National Monument\" width=\"300\" height=\"216\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/10/Canyon-de-Chelly-spider-rock-300x216.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Canyon de Chelly National Monument</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Chinle, Arizona, Verenigde Staten","location":{"lat":"36.1190734","city":"Chinle","state":"Arizona","country":"Verenigde Staten","lng":"-109.3197052","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/canyon-de-chelly-national-monument/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Canyon de Chelly National Monument\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Canyon de Chelly is een nationaal monument in het noordoosten van Arizona. De canyon wordt door de National Park Service beheerd samen met de Navajo tribes die in het gebied leven. Er zijn drie belangrijke canyons te vinden in het gebied: de Chelly, del Muerto en Monument Canyon. In het Canyon de Chelly National Monument vind je nog verschillende overblijfselen van de vroege inheemse stammen die in het gebied leefden. Nog steeds behoort het gebied tot het Navajovolk. Meer weten over Canyon de Chelly en wat je er kunt bezoeken? Onze tips voor Canyon de Chelly National Monument.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">339 km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Navajo tribe\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Canyon de Chelly behoort nog steeds tot het Navajo volk, zij beheren het gebied samen met de National Park Service. Dit houdt in dat bepaalde delen van de kloof beperkt te bezoeken zijn en alleen onder begeleiding door een parkranger of een offici\u00eble Navajogids. De geologische formatie Spider Rock die je in het gebied vindt, verteld het Navajovolk over de kunst van het weven. Voor Navajokinderen is Spider Woman, waarop de rots staat, een les. De kinderen wordt verteld dat als ze zich niet gedragen, Spider Woman ze op zal eten. Tegenwoordig wonen er nog steeds ongeveer 40 Navajofamilies binnen de grenzen van het monument.</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Weidse uitzichten op Canyon de Chelly\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Bezoek \u00e9\u00e9n van de uitkijkpunten\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"17631\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reisperiode Canyon de Chelly \" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Canyon de Chelly bevindt zich midden in de woestijn. Hierdoor heb je zowel in de zomer als in de winter extreme temperaturen. Het park is het hele jaar open waardoor je de mogelijkheid hebt om in het voorjaar of in de herfst te gaan. Je hebt dan nog steeds warme dagen, maar niet te warm. Hierdoor kun je Canyon de Chelly ook wandelend kunt verkennen. Je hebt ongeveer 1 dag nodig om Canyon te Chelly te zien.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten bij Canyon de Chelly \" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De beste uitvalsbasis voor Canyon de Chelly is het dorpje Chinle. Hier vind je een paar hotels waar je kunt overnachten. Een aantal opties:\r\n<ul>\r\n \t<li><a href=\"https://www.booking.com/hotel/us/holiday-inn-canyon-de-chelly-chinle.en.html?aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=chinleholidayinn\" target=\"_blank\" rel=\"noopener\">Holiday Inn Canyon de Chelly- Chinle</a></li>\r\n \t<li><a href=\"https://www.booking.com/hotel/us/best-western-canyon-de-chelly-inn.en.html?aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=chinlebestwestern\" target=\"_blank\" rel=\"noopener\">Best Western Canyon de Chelly Inn</a></li>\r\n \t<li><a href=\"https://www.booking.com/hotel/us/thunderbird-lodge-.en.html?aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=chinlethunderbird\" target=\"_blank\" rel=\"noopener\">Thunderbird Lodge</a></li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Ru\u00efnes in Canyon de Chelly\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_empty_space height=\"10px\"][vc_custom_heading text=\"Restanten van woningen van inheemse stammen\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"17630\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner][vc_custom_heading text=\"Wat te doen in Canyon de Chelly National Monument\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Canyon de Chelly National Monument is een unieke plek in Amerika. Ontdek de South Rim en de North Rim met de auto en stop onderweg bij verschillende uitzichtpunten.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"25px\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/3\"][fullwidth_row content_width=\"70%\"][vc_custom_heading text=\"South Rim\" font_container=\"tag:h3|font_size:30|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_single_image image=\"17626\" img_size=\"large\"][vc_column_text]De South Rim is een 30 kilometer lange weg die je het beste aan het eind van de middag kunt rijden. Onderweg vind je een zevental uitkijkpunten waar je kunt stoppen:\r\n<ol>\r\n \t<li>Tunnel Overlook</li>\r\n \t<li>Tseyi Overlook - plek om de canyon in te kijken, je ziet de Chinle Wash stromen</li>\r\n \t<li>Junction Overlook - uitzicht op de plek waar Canyon de Chelly en Canyon del Muerto splitsen. Junction Ruin is ook te zien, een woning van 10 kamers</li>\r\n \t<li>White House Overlook - startpunt voor White House Ruin Trail</li>\r\n \t<li>Sliding House Overlook - vanaf hier zie je ru\u00efnes die gebouwd zijn in de canyon waar vroeger mensen woonden</li>\r\n \t<li>Face Rock Overlook</li>\r\n \t<li>Spider Rock Overlook - meest spectaculaire plek, vanaf hier zie je Spider Rock het beste</li>\r\n</ol>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"North Rim\" font_container=\"tag:h3|font_size:30|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_single_image image=\"17624\" img_size=\"large\"][vc_column_text]Ook de North Rim is ongeveer 30 kilometer lang en begint bij het bezoekerscentrum. Onderweg heb je iets minder uitzichtpunten dan op de South Rim. Plan de North Rim in de ochtend, dan heb je het mooiste licht om te fotograferen.\r\n<ol>\r\n \t<li>Ledge Ruin Overlook - uitzicht op de Ledge Ruin waar ongeveer 1000 jaar geleden Pueblo woonden</li>\r\n \t<li>Antelope House Overlook - na een kleine wandeling kom je bij ru\u00efnes en wandschilderingen</li>\r\n \t<li>Mummy Cave Overlook - vernoemd naar de 2 mummies die onder de ru\u00efnes gevonden werden</li>\r\n \t<li>Massacre Cave Overlook - op deze plek werden in 1805 tijdens een Spaanse expeditie 115 Navajo's om het leven gebracht</li>\r\n</ol>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/3\"][fullwidth_row content_width=\"70%\"][vc_custom_heading text=\"White House Trail\" font_container=\"tag:h3|font_size:30|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_single_image image=\"17627\" img_size=\"large\"][vc_column_text]Canyon de Chelly verkennen moet grotendeels onder begeleiding van een Navajo gids of Parkranger. De North en South Rim kun je zelfstandig afrijden en de enige wandeling die je zelf kunt maken is de White House Ruin Trail. Deze start bij het White House Overlook uitzichtpunt aan de South Rim. White House is een klein dorpje tegen de canyon wand waar meer dan 1000 jaar geleden mensen woonden. Het wandelpad naar White House is ongeveer 2 kilometer, je daalt 180 meter. Neem voor deze wandeling 2 uur de tijd.[/vc_column_text][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"In de buurt\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:-4792,-4738,-4714,-4689,9996,6209,9826,2661\"][/vc_column][/vc_row]","post_title":"Canyon de Chelly National Monument","post_link":"https://www.heyusa.com/nl/canyon-de-chelly-national-monument/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Canyon de Chelly National Monument\" width=\"300\" height=\"216\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/10/Canyon-de-Chelly-spider-rock-300x216.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Tribal Parken","post_tags":"Arizona","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%inline_featured_image%":"0","%_edit_lock%":"1703754676:1","%_edit_last%":"1","%_thumbnail_id%":"17625","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Canyon de Chelly National Monument","%_yoast_wpseo_metadesc%":"In Arizona vind je het 2e grootse door mensen aangelegde meer Lake Powell. Benieuwd wat je hier kunt doen? Tips voor Lake Powell in Arizona","%_yoast_wpseo_linkdex%":"72","%_wpgmp_location_address%":"Chinle, Arizona, Verenigde Staten","%_wpgmp_location_city%":"Chinle","%_wpgmp_location_state%":"Arizona","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"36.1190734","%_wpgmp_metabox_longitude%":"-109.3197052","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_primary_category%":"39","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1703754620","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_title%":"%%title%% Arizona %%page%% %%sep%% %%sitename%%","taxonomy=category":"Tribal Parken","taxonomy=post_tag":"Arizona","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""}},"id":17619,"infowindow_disable":false},{"source":"post","title":"Lake Powell","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lake Powell in Arizona\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/10/lake-powell-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Lake Powell</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Lake Powell, AZ 86040, Verenigde Staten","location":{"lat":"36.9388464","city":"Lake Powell","state":"Arizona","country":"Verenigde Staten","lng":"-111.4847167","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/lake-powell/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Lake Powell\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Amerika kent een aantal <a href=\"https://www.heyusa.com/nl/mooiste-meren-amerika/\">prachtige meren</a>. Sommigen zijn natuurlijk, anderen door mensen aangelegd. Lake Powell is een meer dat door mensen gemaakt is. Het tweede grootste door mensen gemaakte meer is ontstaan door de bouw van de Glen Canyon Dam. Lake Powell heeft een indrukwekkende kustlijn, met 3050 kilometer is het langer dan de gehele Amerikaanse westkust. Lake Powell en de Glen Canyon Dam zijn onderdeel van het Navajo reservaat.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">658 km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Ontstaan Lake Powell\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Lake Powell is ontstaan door de overstroming van Glen Canyon waardoor besloten werd tot de bouw van een dam. Hierdoor ontstond het <a href=\"https://www.heyusa.com/nl/glen-canyon-recreation-area/\">Glen Canyon National Recreation Area</a>. Het stuwmeer, Lake Powell, is vernoemd naar John Wesley Powell, een veteraan uit de burgeroorlog die in 1869 de rivier met 3 houten boten verkende. Het meer biedt mogelijkheden voor het opslaan van water voor de Upper Basin staten van de Colorado rivier (Colorado, Utah, Wyoming en New Mexico). Daarnaast zorgt het voor stroom in de Lower Basin staten (Arizona, Nevada en Californi\u00eb).</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Met een boot op Lake Powell\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"De beste manier om Lake Powell te verkennen\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"17612\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Facts Lake Powell\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Sinds 2000 is er sprake van een mega droogte in het zuidwesten van Noord Amerika. Ook Lake Powell heeft hieronder te leiden. 2005 was het jaar waarin het laagste niveau van de waterstand werd bereikt. Gelukkig is het de afgelopen jaren iets hersteld, maar het niveau is nog niet op het oude peil. De capaciteit van Lake Powell is sinds 1963 met 7% afgenomen als gevolg van de instroom van sedimenten uit de Colorado rivier en de San Juan rivier.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Beste reisperiode Lake Powell\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Tussen juni en oktober kun je Lake Powell het beste bezoeken. De maanden juni, juli en augustus zijn de drukste maanden met warme dagen(35-37 graden) en goede watertemperaturen. Wil je een iets rustigere periode? Ga dan in september en oktober naar Lake Powell. De watertemperaturen zijn nog steeds goed, maar de temperaturen iets lager (tussen 23-30 graden).[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Overnachten bij Lake Powell\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De beste uitvalsbasis voor Lake Powell is Page. Hier vind je verschillende hotels waar je kunt overnachten. Een aantal opties:\r\n<ul>\r\n \t<li><a href=\"https://www.booking.com/hotel/us/courtyard-page-at-lake-powell.en.html?aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=lakepowellcourtyard\" target=\"_blank\" rel=\"noopener\">Courtyard Page at Lake Powell</a></li>\r\n \t<li><a href=\"https://www.booking.com/hotel/us/best-western-at-lake-powell.en.html?aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=lakepowellbestwestern\" target=\"_blank\" rel=\"noopener\">Best Western Plus at Lake Powell</a></li>\r\n \t<li><a href=\"https://www.booking.com/hotel/us/hyatt-place-page-lake-powell.en.html?aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=lakepowellhyatt\" target=\"_blank\" rel=\"noopener\">Hyatt Place Page Lake Powell</a></li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Rainbow Bridge\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][vc_custom_heading text=\"E\u00e9n van de natuurlijke highlights\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"9999\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner][vc_custom_heading text=\"Wat te doen bij Lake Powell\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Op en rondom Lake Powell is genoeg te doen. Denk aan watersporten, wandelen en prachtige natuurfenomenen om te bezoeken. Combineer je Lake Powell met <a href=\"https://www.heyusa.com/nl/bezienswaardigheden-page-arizona/\">Page</a> in Arizona? Dan kun je hier zelfs een paar dagen verblijven. Onze tips voor Lake Powell.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"25px\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/2\"][fullwidth_row content_width=\"70%\"][vc_custom_heading text=\"Bootje varen op Lake Powell\" font_container=\"tag:h3|font_size:30|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_single_image image=\"17612\" img_size=\"large\"][vc_column_text]Lake Powell kun je natuurlijk het beste verkennen vanaf het water. Er zijn verschillende watersport-activiteiten mogelijk. Met een rondvaart over Lake Powell krijg je een goede indruk van het meer. Je kunt op twee plekken een rondvaart boeken: vanaf Wahweap Marina en Antelope Point Marina. Je kunt de rondvaart het beste online boeken, vanaf Antelope Point Marina zijn ze vaak net iets goedkoper. Andere watersport-activiteiten zijn waterski\u00ebn, kano\u00ebn, wakeboarden en suppen.[/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Rainbow Bridge Monument\" font_container=\"tag:h3|font_size:30|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_single_image image=\"9999\" img_size=\"large\"][vc_column_text]E\u00e9n van de mooiste natuurlijke bezienswaardigheden in Utah is de Rainbow Bridge. Een natuurlijke boog met een overspanning van 84 meter en een hoogte van 88 meter. De brug is van cultureel belang voor een aantal <a href=\"https://www.heyusa.com/nl/native-americans/\">inheemse Amerikaanse stammen</a> en is aangewezen als traditioneel cultureel bezit. De makkelijkste manier om Rainbow Bridge te bezoeken is met een twee uur durende boottocht over Lake Powell. Wandelen vanaf Navajo Mountain is ook mogelijk, maar daarvoor is een goede voorbereiding noodzakelijk. Je hebt een vergunning nodig die je aan kunt vragen bij het Navajo hoofdkwartier in Window Rock. Houd er rekening mee dat het respectloos is om over of onder de brug door te lopen, Rainbow Bridge is een religieuze plek voor de Navajo indianen.[/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/2\"][fullwidth_row content_width=\"70%\"][vc_custom_heading text=\"Glen Canyon Dam\" font_container=\"tag:h3|font_size:30|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_single_image image=\"17616\" img_size=\"large\"][vc_column_text]De Glen Canyon Dam is een indrukwekkende bezienswaardigheid in de buurt van Lake Powell en Page. Je kunt de Glen Canyon Dam enigszins vergelijken met de <a href=\"https://www.heyusa.com/nl/hoover-dam-nevada/\">Hoover Dam</a>. De dam heeft een hoogte van 457 meter. Bij het Carl Hayden Visitor Center aan de westkant van de dam kun je meer informatie krijgen over de Glen Canyon Dam. Er zijn tentoonstellingen en je kunt mee met een rondleiding om het indrukwekkende bouwwerk te bekijken.[/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Wandelen rondom Lake Powell\" font_container=\"tag:h3|font_size:30|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_single_image image=\"6215\" img_size=\"large\"][vc_column_text]De beste plek om te wandelen rondom Lake Powell is in de buurt van Wahweap Marina. Je vindt hier trails voor ieder niveau. Je kunt de Glen Canyon Dam Overlook\u00a0 of de Horseshoe Bend Trail wandelen. Er zijn een aantal trails waarvoor je eerst met de boot dient te gaan. Zo is de Navajo Canyon een makkelijke wandeling waarvoor je eerst een boot of kajak nodig hebt. Ook voor een bezoek aan Rainbow Bridge dien je eerst een stuk via het water af te leggen.[/vc_column_text][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"In de buurt\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:-4792,-4738,-4714,-4689,9996,6209,9826,2661\"][/vc_column][/vc_row]","post_title":"Lake Powell","post_link":"https://www.heyusa.com/nl/lake-powell/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lake Powell in Arizona\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/10/lake-powell-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Natuurgebieden","post_tags":"Arizona","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%inline_featured_image%":"0","%_edit_lock%":"1696841891:2","%_edit_last%":"2","%_thumbnail_id%":"17611","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Lake Powell","%_yoast_wpseo_metadesc%":"In Arizona vind je het 2e grootse door mensen aangelegde meer Lake Powell. Benieuwd wat je hier kunt doen? Tips voor Lake Powell in Arizona","%_yoast_wpseo_linkdex%":"73","%_wpgmp_location_address%":"Lake Powell, AZ 86040, Verenigde Staten","%_wpgmp_location_city%":"Lake Powell","%_wpgmp_location_state%":"Arizona","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"36.9388464","%_wpgmp_metabox_longitude%":"-111.4847167","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_primary_category%":"227","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1696842004","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_title%":"%%title%% Arizona %%page%% %%sep%% %%sitename%%","taxonomy=category":"Natuurgebieden","taxonomy=post_tag":"Arizona","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""}},"id":17608,"infowindow_disable":false},{"source":"post","title":"Saguaro National Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Saguaro National Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/09/Saguaro-National-Park-kopieren-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Saguaro National Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Arizona, Verenigde Staten","location":{"lat":"32.29673590000001","state":"Arizona","country":"Verenigde Staten","lng":"-111.166615","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/saguaro-national-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Saguaro National Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De staat Arizona kent 3 nationale parken waarvan het Grand Canyon National Park verreweg de bekendste is. De andere twee nationale parken zijn een stuk minder bekend, maar net zo uniek in hun soort. Het Petrified Forest National Park en het Saguaro National Park laten zien hoe divers de staat Arizona is qua natuur. Het Saguaro National Park is \u00e9\u00e9n van de droogste plekken in Amerika en heeft zijn naam te danken aan de Saguaro cactus. Benieuwd naar het Saguaro National Park? Lees dan onze tips voor dit nationale park in Arizona.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]32\u00a0 &amp; 24 kilometer vanaf Tucson[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">354,2 km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-paw\"]200 verschillende vogels[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Saguaro Cactus\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">De reuzencactus Saguaro is de bekendste attractie van het Saguaro National Park. De unieke cactus kan tot 15 meter hoog worden en is daarmee de grootste cactus die er is. Hij is ook de langzaamst groeiende cactus. Pas na 50 jaar bereikt hij een lengte van 2 meter, met 75 jaar beginnen de vertakkingen en met 150 jaar is hij pas volledig volgroeid. De Saguaro is het symbool van Arizona en staat in bloei tussen april en juni. 's Nachts en in de vroege ochtend, wanneer de temperaturen nog laag zijn, is hij het mooist.</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Saguaro cactus in bloei\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Kom tussen april en juni naar het park\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"17495\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Facts Saguaro National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Saguaro National Park bestaat in tegenstelling tot de andere nationale parken uit 2 delen. E\u00e9n deel ligt op 32 kilometer ten oosten van de stad Tucson, de andere op 24 kilometer ten westen van Tucson. Je kunt zeggen dat de stad Tucson het park scheidt. Je vindt in het Saguaro National Park een woestijnklimaat, de zomers zijn warm en er valt in het jaar maar zo'n 30 cm regen. De flora en fauna zijn ingespeeld op dit weer. Want hoewel je het misschien niet verwacht, zijn er in het park vele soorten bomen, planten en dieren te vinden. In totaal zijn er meer dan 1000 inheemse planten, 200 vogels en komen dieren als coyotes, halsbandpekari's vaak voor. Ook leven er zwarte beren en poema's in het Saguaro Nationale Park.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Wat te doen in Saguaro National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Doordat het Saguaro National Park uit 2 delen bestaat, zijn er verschillende bezienswaardigheden per deel te bezoeken. Het oostelijke deel van de Saguaro is meer gericht op geschiedenis en geologie. Hier vind je ook de oudste Saguaro cactussen. Je kunt hier de 13 kilometer lange Cactus Forest Drive rijden om het park te bekijken. Aan deze weg starten verschillende wandelroutes. De wegen zijn in dit deel verhard. Het westelijke deel bevat meer ongerepte natuur. De wegen zijn hier grotendeels onverhard met uitzondering van de weg naar het visitor center en de Desert Discovery Trail. Bezoek in het westelijke deel de Signal Hill Picnic Area, waar je eeuwenoude rotstekeningen kunt zien.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten in Saguaro National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Er zijn geen hotels of cabins te huur in het Saguaro National Park. Enkele kleine campsites met een paar plekken zijn er in het park die je alleen wandelend kunt bereiken. Wil je in een hotel overnachten? Kijk dan voor <a href=\"https://www.booking.com/searchresults.en.html?city=20007417&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=Saguarotucson\" target=\"_blank\" rel=\"noopener\">mogelijkheden in Tucson</a>. Aangezien de stad midden tussen de twee delen ligt, de beste uitvalsbasis om het park te verkennen.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reisperiode Saguaro National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Saguaro National Park kun je het beste bezoeken van oktober tot en met april. In deze periode liggen de temperaturen overdag rond de 20 graden en koelt het 's nachts af naar het vriespunt. Ben je in april? Dan heb je kans om de Saguaro te zien bloeien. De warmste maanden zijn mei tot en met september. De temperaturen liggen dan rond de 40 graden overdag. Tussen januari en maart kunnen enkele (hele) lichte regenbuien voorkomen.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Trails in het Saguaro National Park\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_empty_space height=\"10px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Ontdek het park op \u00e9\u00e9n van de wandelpaden\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"17493\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelen in Saguaro National Park\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]In het Saguaro National Park zijn er verschillende mogelijkheden om te wandelen. Een aantal wandelingen die de moeite waard zijn in het oosten:\r\n<ul>\r\n \t<li>Freeman Homestad Trail (2 kilometer)</li>\r\n \t<li>Loma Verde Loop (6 kilometer)</li>\r\n \t<li>Hope Camp and Ridgeview Trail (3,2 kilometer)</li>\r\n \t<li>Garwood Dam and Wildhorse Tank (10 kilometer)</li>\r\n</ul>\r\nIn het westen kun je de volgende wandelingen doen:\r\n<ul>\r\n \t<li>Wild Dog Trail (2,8 kilometer)</li>\r\n \t<li>King Canyon / Gould Mine Loop (3,8 kilometer)</li>\r\n \t<li>Sendero Esperanza Trail (5,6 kilometer)</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]24/7 en 365 dagen geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: oktober t/m april[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]$25 auto\r\n$15 persoon[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Sunset in het Saguaro National Park \" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_empty_space height=\"10px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Bekijk de indrukwekkende zonsondergang in het park\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"17496\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Meer Arizona\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:-17318,-15062,-14907,-14250,-4792,-4738,-4714,-4689,3208,4574,1971,8742\"][/vc_column][/vc_row]","post_title":"Saguaro National Park","post_link":"https://www.heyusa.com/nl/saguaro-national-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Saguaro National Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/09/Saguaro-National-Park-kopieren-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Saguaro National Park","post_tags":"Arizona","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%inline_featured_image%":"0","%_edit_lock%":"1695626212:2","%_edit_last%":"2","%_thumbnail_id%":"17494","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Saguaro National Park","%_yoast_wpseo_metadesc%":"In Arizona vind je het Saguaro National Park, bekend van de Saguaro cactus. Tips voor een bezoek aan het Saguaro National Park.","%_yoast_wpseo_linkdex%":"79","%_wpgmp_location_address%":"Arizona, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Arizona","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"32.29673590000001","%_wpgmp_metabox_longitude%":"-111.166615","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_primary_category%":"204","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1695626280","%_last_editor_used_jetpack%":"classic-editor","%_wp_old_date%":"2023-08-18","%_wp_old_slug%":"saguaro-national-park","taxonomy=category":"Saguaro National Park","taxonomy=post_tag":"Arizona","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""}},"id":17477,"infowindow_disable":false},{"source":"post","title":"Haleakala National Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Heleakala National Park op Maui\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/09/haleakala-np-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Haleakala National Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Hawa\u00ef, Verenigde Staten","location":{"lat":"20.7203826","state":"Hawa\u00ef","country":"Verenigde Staten","lng":"-156.1551524","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/haleakala-national-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Heleakala National Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Hawaii kende lange tijd maar \u00e9\u00e9n national park. Vanaf 1961 werden het Haleakala National Park en het Hawaii Volcanoes National Park gesplitst. Op zich logisch, want beide parken liggen op een ander eiland. Het Haleakala National Park is vernoemd naar de Haleakala vulkaan op het eiland Maui en beslaat het grootste deel van het eiland. Een indrukwekkend vulkanisch landschap waar je zeker met zonsopkomst en zonsondergang een keer naar toe moet. Alle tips voor een bezoek aan het Haleakala National Park.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]45 kilometer vanaf Kahului[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">134,6 km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-paw\"]Geen dieren, alleen verschillende soorten vogels[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Vulkaan Haleakala\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">De naam Haleakala werd vroeger door de Hawaiianen toegepast op de algemene berg en betekent huis van de zon. In de Hawaiiaanse folklore was de top van de krater de thuisbasis van de grootmoeder van halfgod Maui. De legende vertelt dat Maui's grootmoeder hem hielp de zon te vangen en haar te dwingen haar reis door de lucht te vertragen om de dag te verlengen.</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Sliding Sands Trail in Haleakala National Park\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Indrukwekkende trail\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"17328\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Facts Haleakala National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Haleakala National Park is vernoemd naar de gelijknamige vulkaan op het eiland <a href=\"https://www.heyusa.com/nl/wat-te-doen-op-maui-hawaii/\">Maui</a> in Hawaii. De schildvulkaan bedekt meer dan 75% van het hele eiland en heeft een hoogte van 3055 meter. Het is inmiddels jaren geleden dat hij is uitgebarsten, naar alle waarschijnlijkheid was de laatste uitbarsting tussen 1480 en 1600. Daarvoor was de vulkaan jarenlang actief en kende talloze uitbarstingen. De top van de vulkaan is een bezienswaardigheid op zich. Vanaf hier kun je de krater in wandelen en er staan een aantal telescopen vanwaar het Amerikaanse ministerie van defensie naar satellieten en raketten kijkt. De top kun je met de auto bereiken.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Wat te doen in Haleakala National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Haleakala National Park kun je splitsen in twee gedeelten: Het Summit District en het Kipahulu District. Onder het eerste deel vallen de kraters van de vulkanen, het Kipahulu district ligt meer in het zuidoosten van Maui en is onderdeel van de Road to Hana. Er is genoeg te doen in het Haleakala National Park. Een aantal aanraders zijn Hosmers's Grove (een uniek bos), sterren kijken, zonsopkomst en zonsondergang op de Haleakala Crater, Ohe'O Gulch, Waimoku Falls, Red Hill (hoogste punt Maui), Kalahaku overlook en de Leleiwi overlook. Er lopen verschillende mooie wandelingen in het gebied, een goede manier om kennis te maken met het vulkanisch landschap van het Haleakala National Park.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten in Haleakala National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Overnachten in het Haleakala National Park is niet mogelijk. Je hebt rondom het park verschillende opties voor accommodaties. Aan de zuidkant kunnen de plekken <a href=\"https://www.booking.com/searchresults.en.html?city=20031040&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=haleakalanationalparkkihei\" target=\"_blank\" rel=\"noopener\">Kihei</a> en <a href=\"https://www.booking.com/searchresults.en.html?city=900040794&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=haleakalanationalparkwailea\" target=\"_blank\" rel=\"noopener\">Wailea</a> goede uitvalsbasissen zijn. Een andere mogelijkheid is de westkant van het Haleakala National Park, hier zijn <a href=\"https://www.booking.com/searchresults.en.html?city=20031073&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=haleakalanationalparklahaina\" target=\"_blank\" rel=\"noopener\">Lahaina</a>, <a href=\"https://www.booking.com/searchresults.en.html?city=20030935&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=haleakalanationalparkkaanapali\" target=\"_blank\" rel=\"noopener\">Kaanapali</a> en <a href=\"https://www.booking.com/searchresults.en.html?city=20030989&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=haleakalanationalparkkapalua\" target=\"_blank\" rel=\"noopener\">Kapalua</a> opties om te verblijven.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reisperiode Haleakala National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Haleakala National Park kun je het hele jaar bezoeken. Tussen november en april is het regenseizoen en heb je meer kans op buien. Vanaf mei tot oktober is het droger, maar is het direct ook drukker in het park. De beste periode om het Haleakala National Park te bezoeken is in de maanden mei, september en oktober.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Trails in het Haleakala National Park\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Ontdek het park op \u00e9\u00e9n van de wandelpaden\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"17327\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelen in Haleakala National Park\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]In het Haleakala National Park zijn er verschillende mogelijkheden om te wandelen. In het Summit District vind je 48 kilometer aan hiking trails, van makkelijke wandelingen tot meerdaagse wandelingen. Doordat je redelijk op hoogte wandelt, is het goed om hoogteziekte in de gaten te houden. Ook het weer en de temperatuur kunnen ineens omslaan. Een aantal wandelingen die de moeite waard zijn:\r\n<ul>\r\n \t<li>Sliding Sands Trail: ongeveer 17-20 kilometer</li>\r\n \t<li>Pa Ka'oao: 0,64 kilometer</li>\r\n \t<li>Hosmer Grove: 0,87 kilometer</li>\r\n \t<li>Halemau'u Trail: 3,6 kilometer</li>\r\n \t<li>Pipiwai Trail: 6,4 kilometer</li>\r\n \t<li>Kuloa Point Trail: 1,2 kilometer</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]24/7 en 365 dagen geopend\r\nVoor zonsopkomst op de Haleakala krater moet je <a href=\"https://www.recreation.gov/ticket/facility/253731\" target=\"_blank\" rel=\"noopener\">reserveren</a>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: mei, september, oktober[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]$30[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Ohe'O Gulch\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Seven secret pools\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"17326\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Meer Hawaii\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:-4792,-4738,-4714,-4689,15062,17318,14907,14250\"][/vc_column][/vc_row]","post_title":"Haleakala National Park","post_link":"https://www.heyusa.com/nl/haleakala-national-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Heleakala National Park op Maui\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/09/haleakala-np-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Haleakala National Park","post_tags":"Hawaii","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%inline_featured_image%":"0","%_edit_lock%":"1694873673:2","%_edit_last%":"2","%_thumbnail_id%":"17319","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Haleakala National Park","%_yoast_wpseo_metadesc%":"In Hawaii ligt het Haleakala National Park, een park bestaand uit een vulkaanlandschap. Tips voor een bezoek aan het Haleakala National Park.","%_yoast_wpseo_linkdex%":"84","%_wpgmp_location_address%":"Hawa\u00ef, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Hawa\u00ef","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"20.7203826","%_wpgmp_metabox_longitude%":"-156.1551524","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_primary_category%":"233","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1694873781","%_last_editor_used_jetpack%":"classic-editor","%_wp_old_date%":"2023-08-18","taxonomy=category":"Haleakala National Park","taxonomy=post_tag":"Hawaii","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""}},"id":17400,"infowindow_disable":false},{"source":"post","title":"Tips voor bezienswaardigheden in Honolulu","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Honolulu Oahu\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/08/honolulu-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Tips voor bezienswaardigheden in Honolulu</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Sanibel Island, Florida, Verenigde Staten","location":{"lat":"26.4433972","state":"Florida","country":"Verenigde Staten","lng":"-82.1115119","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/bezienswaardigheden-honolulu/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"75px\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"25px\"][vc_empty_space height=\"25px\"][ultimate_heading main_heading=\"Bezienswaardigheden in Honolulu\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Het eiland <a href=\"https://www.heyusa.com/nl/wat-te-doen-oahu-hawaii/\"><strong>Oahu</strong></a> bestaat uit 5 verschillende regio's, \u00e9\u00e9n daarvan is Honolulu. Honolulu is de hoofdstad van de staat <a href=\"https://www.heyusa.com/nl/hawaii/\" target=\"_blank\" rel=\"noopener\">Hawaii</a> en daarnaast ook de grootste stad van Hawaii. Het is een bruisende stad met veel restaurants, historische plaatsen, musea, bezienswaardigheden, winkels en zelfs de natuur is nooit ver weg. Denk aan surfen op Waikiki Beach, wandelen bij Diamond Head of snorkelen in Hanauma Bay. Honolulu is de perfecte plek voor de start van je reis op Hawaii.<strong>\r\n</strong>[/vc_column_text][vc_empty_space height=\"75px\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Tips voor bezienswaardigheden in Honolulu\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"17316\" img_size=\"large\" add_caption=\"yes\"][ultimate_heading main_heading=\"Lolani Palace\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">E\u00e9n koninklijk paleis is er te vinden in Amerika en die staat in Honolulu. Het Iolani paleis was de voormalige residentie van het staatshoofd van Hawaii uit de tijd dat Hawaii nog een koning had. Kalakaua was de eerste koning in 1879, de laatste was koningin Liliuokalani in 1893. Je kunt het paleis bezoeken, <a href=\"https://www.iolanipalace.org/visit/\" target=\"_blank\" rel=\"noopener\">reserveren</a> is aan te raden.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"6716\" img_size=\"large\" add_caption=\"yes\"][ultimate_heading main_heading=\"Hanauma Bay Nature Preserve\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Hanauma Bay is de perfecte escape in de buurt van Honolulu om te relaxen op het strand. De kust bestaat uit redelijk ondiep water en is daardoor ook geschikt om te snorkelen. Er zwemmen tropische vissen niet ver uit de kust. Hanauma Bay is alleen per auto of uber te bezoeken, er gaan geen tourbussen die kant op. Omdat het state park is, dien je <a href=\"https://pros6.hnl.info/\" target=\"_blank\" rel=\"noopener\">tickets te kopen (en reserveren)</a> voor de parkeerplaats.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"17289\" img_size=\"large\" add_caption=\"yes\"][ultimate_heading main_heading=\"Makapu'u Point Lighthouse trail\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Om het Makapu'u Point Lighthouse te bereiken, kun je de 3 kilometer lange Makapu'u Point Lighthouse Trail wandelen. Een relatief makkelijke route waarbij je onderweg kans hebt om walvissen te zien (tussen november en mei). De vuurtoren werd in 1909 gebouwd. Niet alleen onderweg, maar ook hier heb je een goed uitzicht op de oceaan.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"10019\" img_size=\"large\" add_caption=\"yes\"][ultimate_heading main_heading=\"Koko Crater Trail\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">De Koko Crater Trail is een trail van ongeveer 5 kilometer naar de top van de Koko Head Crater. Een route langs meer dan 1000 treden die gemaakt zijn van oude spoorbielzen. Op de top van het pad krijg je een panoramisch uitzicht op het Hanauma Bay Nature Preserve en Diamond Head State Monument. Zorg dat je goed voorbereid op pad gaat met goede schoenen en voldoende water. Wil je echt de ultieme ervaring? Kom dan voor 05.00 uur bij de trail om geen last te hebben van de hitte en de zon zien opkomen. Neem wel een hoofdlamp mee als je dit gaat doen.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"17315\" img_size=\"large\" add_caption=\"yes\"][ultimate_heading main_heading=\"Bishop Museum\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Cultuur- en geschiedenisliefhebbers kunnen een bezoek brengen aan het Bishop Museum in Honolulu. Het is een museum voor geschiedenis en wetenschap en de grootste op Hawaii. Je vindt er een enorme collecte Polynesische culturele artefacten en natuurhistorische bezienswaardigheden. Daarnaast kun je meer te weten komen over de Hawaiiaanse cultuur.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"10019\" img_size=\"large\" add_caption=\"yes\"][ultimate_heading main_heading=\"Manoa Falls\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Op ongeveer 8 kilometer ten noordoosten van Honolulu ligt de Manoa Falls. De 45 meter hoge waterval is makkelijk te bereiken, de trail er naar toe is ongeveer 1,5 kilometer. Toch is aan te raden goede schoenen aan te doen, het pad kan namelijk glad zijn. Je wandelt door een regenwoud landschap waar ook enkele scenes van Jurassic Park zijn opgenomen. Om de drukte te vermijden raden we aan om voor 10.00 uur te komen. Er is geen toegangsprijs, maar je dient wel parkeergeld te betalen. Je kunt ook met bus 5 naar de watervallen.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Waikiki Beach en Diamond Head\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Twee publiekstrekkers\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"17392\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" thb_row_padding=\"true\" thb_column_padding=\"true\" content_placement=\"middle\"][vc_column width=\"1/2\"][vc_empty_space height=\"25px\"][vc_row_inner][vc_column_inner width=\"5/6\"][vc_custom_heading text=\"Pearl Harbor\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" heading=\"Stukje geschiedenis\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][vc_column_text]\r\n<p style=\"text-align: left;\">Hoewel het iets uit de buurt van Honolulu ligt, is het <a href=\"https://www.heyusa.com/nl/pearl-harbor/\">Pearl Harbor</a> National Memorial aan te raden om te bezoeken. Je vindt er het USS Arizona Memorial, een laatste rustplaats voor meer dan 900 matrozen en mariniers die omgekomen zijn tijdens de aanval op Pearl Harbor. Op 7 december 1941 werd de basis aangevallen door Japanse vliegtuigen. Een gezonken slagschip herinnert aan de aanval. Een bezoek aan de USS Arizona Memorial is gratis, maar je dient van te voren een tijdslot te reserveren.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"25px\"][fullwidth_row content_width=\"100%\"][thb_image retina=\"retina_size\" full_width=\"true\" image=\"14304\"][/thb_image][/vc_column][/vc_row][vc_row thb_full_width=\"true\" thb_row_padding=\"true\" thb_column_padding=\"true\" content_placement=\"middle\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][thb_image retina=\"retina_size\" full_width=\"true\" image=\"15256\"][/thb_image][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/2\"][vc_row_inner][vc_column_inner width=\"5/6\"][vc_custom_heading text=\"Waikiki Beach\" font_container=\"tag:h3|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" heading=\"Tropisch paradijs\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][vc_column_text]\r\n<p style=\"text-align: left;\">De wijk Waikiki in Honolulu is al jaren een geliefde plek. De reden? Het prachtige strand dat inmiddels wereldberoemd is. Je vindt er zachte zandstranden en hoge golven tijdens de wintermaanden. Voor surfers een walhalla en om te snorkelen is Waikiki perfect, maar ook voor mensen die er komen om te ontspannen. Grenzend aan Waikiki Beach liggen tal van restaurants en winkels. Daarnaast kijken vele hotels uit op Waikiki Beach.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1689956280731{padding-top: 50px !important;padding-bottom: 50px !important;background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2021/08/all-day-usa-background.gif?id=8408) !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][heyusa_heading tag=\"div\" heading=\"Handige info van de redactie\" font_size=\"43\" line_height=\"45\" font_color=\"#b34a4c\"][vc_custom_heading text=\"Essenti\u00eble tips voor reizen naar Honolulu:\" font_container=\"tag:h3|font_size:25|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][vc_row_inner box_shadow=\"large-shadow\" css=\".vc_custom_1689955486087{background-color: #ffffff !important;border-radius: 10px !important;}\"][vc_column_inner][vc_empty_space height=\"25px\"][ultimate_icon_list icon_size=\"65\" icon_margin=\"10\"][ultimate_icon_list_item icon_type=\"custom\" icon_img=\"id^16758|url^https://www.heyusa.com/nl/wp-content/uploads/2023/07/heyusa-expert-tip.png|caption^Hey!USA Expert Tip over reizen naar Amerika|alt^Hey!USA Expert Tip over reizen naar Amerika|title^Hey!USA Expert Tip over reizen naar Amerika|description^Hey!USA Expert Tip over reizen naar Amerika\" content_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" content_font_size=\"desktop:25px;\" content_font_color=\"#282828\"]Hey!USA\r\npersoonlijke tips:[/ultimate_icon_list_item][/ultimate_icon_list][vc_column_text]\r\n<ul>\r\n \t<li>Hoe lang verblijven? 3<em>\u00a0volle dagen</em></li>\r\n \t<li>Auto nodig?\u00a0<em><a href=\"https://www.heyusa.com/nl/auto-huren-in-amerika/\">Huurauto</a> is noodzakelijk</em></li>\r\n \t<li>Beste periode? <em>Tussen midden april en begin juni en tussen september en midden december</em></li>\r\n \t<li>Drukste maanden? <em>Midden december tot maart</em></li>\r\n \t<li>Warmste maand? <em>Augustus</em></li>\r\n \t<li>Meeste regen? <em>November, december en januari</em></li>\r\n \t<li>Hotel aanbevelingen: <a href=\"https://www.booking.com/hotel/us/halekulani.en.html?aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=Honoluluhalekulani\" target=\"_blank\" rel=\"noopener\">Halekulani</a> |<a href=\"https://www.booking.com/hotel/us/the-kahala-and-resort.en.html?aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=Honolulukahalaresort\" target=\"_blank\" rel=\"noopener\">Kahala Hotel &amp; Resort</a> | <a href=\"https://www.booking.com/hotel/us/hawaii-price-waikiki.en.html?aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=Honoluluprincewaikiki\" target=\"_blank\" rel=\"noopener\">Prince Waikiki</a></li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Meer Hawaii\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][fullwidth_row][thb_postgrid columns=\"4\" source=\"post_type:post|by_id:-16507,-16400,-16342,-16174,-15355,-15163,-4725,-1559,17284,14907,15249,14250\"][/vc_column][/vc_row]","post_title":"Tips voor bezienswaardigheden in Honolulu","post_link":"https://www.heyusa.com/nl/bezienswaardigheden-honolulu/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Honolulu Oahu\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/08/honolulu-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Stedentrips","post_tags":"Hawaii","%_wpb_shortcodes_custom_css%":".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1689956280731{padding-top: 50px !important;padding-bottom: 50px !important;background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2021/08/all-day-usa-background.gif?id=8408) !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}.vc_custom_1689955486087{background-color: #ffffff !important;border-radius: 10px !important;}","%_edit_lock%":"1694873197:2","%_edit_last%":"2","%_wpb_vc_js_status%":"true","%post-primary-category%":"16","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Honolulu","%_yoast_wpseo_title%":"Wat te doen in Honolulu%%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"De grootste stad van Hawaii, Honolulu. Wat te doen in Honolulu? Tips voor bezienswaardigheden in Honolulu.","%_yoast_wpseo_linkdex%":"75","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"wat te doen op Honolulu\"]","%_wpgmp_location_address%":"Sanibel Island, Florida, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"26.4433972","%_wpgmp_metabox_longitude%":"-82.1115119","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1694873303","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_primary_category%":"62","%post_via%":"","%_thumbnail_id%":"17287","%standard-featured-credit%":"","taxonomy=category":"Stedentrips","taxonomy=post_tag":"Hawaii","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":17388,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Lake Tahoe","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lake Tahoe in Nevada\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/08/sandy-harbor-beach-lake-tahoe-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Lake Tahoe</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Lake Tahoe, Verenigde Staten","location":{"lat":"39.0968493","country":"Verenigde Staten","lng":"-120.0323507","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/lake-tahoe/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Lake Tahoe\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Lake Tahoe is een groot meer dat je vindt op de grens tussen Californi\u00eb en Nevada. Het is \u00e9\u00e9n van de meest populaire bestemmingen in de regio, vooral veel locals gaan graag naar Lake Tahoe. Het is een zomer- en winterbestemming, waardoor Lake Tahoe het hele jaar door gewild is. In de zomermaanden kun je er wandelen, zwemmen en boot varen. In de wintermaanden zijn er verschillende skigebieden om te bezoeken. Tips voor een bezoek aan Lake Tahoe.[/vc_column_text][vc_custom_heading text=\"Hey!USA Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Boek je hotel in South Lake Tahoe of Stateline. Zo kun je en het meer en de omgeving verkennen!\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:100%20light%20regular%3A100%3Anormal\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612950540814{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Lake Tahoe\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Lake Tahoe is het op \u00e9\u00e9n na diepste meer in Amerika. Het meer ontstond door een geologische breuk waardoor land aan beide kanten omhoog gestuwd werd. Lake Tahoe ontstond door schuivende gletsjers. Het meer wordt gevoed door verschillende bergstromen, er is slechts 1 uitstroom: de Truckee. Voordat Lake Tahoe een populaire toeristische bestemming werd, leefden er Washo-indianen in de regio. Op het moment dat er goud en zilver werd gevonden rond 1840, werd het een belangrijke plek. Er kwamen vakantieoorden, villa's, casino's en wintersportgebieden die ervoor zorgen dat Lake Tahoe het hele jaar door een gewilde bestemming is.</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Lake Tahoe\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Het hele jaar door een bestemming om te bezoeken\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"17212\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"17215\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Lake Tahoe in de winter\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Lake Tahoe is \u00e9\u00e9n van de beste <a href=\"https://www.heyusa.com/nl/skien-in-amerika/\">wintersportgebieden in Amerika</a>. Met bijna een miljoen bezoekers per jaar, staat het in de top 10 van wintersportbestemmingen. De meeste skigebieden liggen aan de noordkant van het gebied bij Truckee en Reno. In het zuiden is Heavenly Mountain Resort een groot skigebied. In 1960 vonden de Olympische Winterspelen plaats in Palisades Tahoe, het tweede grootste skigebied.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"17214\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Lake Tahoe in de zomer\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Vanaf de late lente tot in het begin van de herfst is Lake Tahoe een gewilde bestemming voor vooral inwoners van Californi\u00eb en Nevada. De meeste toeristen kiezen er voor om richting <a href=\"https://www.booking.com/searchresults.en.html?city=20016087&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=laketahoesouthlake\" target=\"_blank\" rel=\"noopener\">South Lake Tahoe</a> en <a href=\"https://www.booking.com/searchresults.en.html?city=20079339&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=laketahoestateline\" target=\"_blank\" rel=\"noopener\">Stateline</a> te reizen. Een andere populaire plek in het noorden is Kings Beach. Dit zijn ook de plekken waar je vele watersport activiteiten zoals <a href=\"https://www.getyourguide.nl/lake-tahoe-l889/lake-tahoe-kajakverhuur-aan-de-noordkust-t249337/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=laketahoekajak\" target=\"_blank\" rel=\"noopener\">kajakken</a> of <a href=\"https://www.getyourguide.nl/lake-tahoe-l889/lake-tahoe-verhuur-van-stand-up-paddleboards-aan-de-noordkust-t249987/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=laketahoesupp\" target=\"_blank\" rel=\"noopener\">suppen</a> kunt ondernemen. Ook wandelen en <a href=\"https://www.getyourguide.nl/incline-village-l149953/lake-tahoe-stadsfiets-dagverhuur-t445330/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=laketahoefiets\" target=\"_blank\" rel=\"noopener\">fietsen</a> zijn populair in Lake Tahoe. Er zijn verschillende trails en fietspaden. Het langste en beroemdste wandelpad is de Tahoe Rim Trail, een route van 270 kilometer rondom het meer.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][thb_postbackground source=\"size:1|post_type:post|by_id:-1619,-667,14830\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"75px\"][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ontdek meer natuur in de buurt\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][ultimate_heading main_heading=\"Nog meer Nevada\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:40px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:45px;\"][/ultimate_heading][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"25px\"][thb_postbackground style=\"style2\" source=\"by_id:-15644,-15627,-15580,-8105,-1262,-2267,-572,-545,3720,12148,4460,4663\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row]","post_title":"Lake Tahoe","post_link":"https://www.heyusa.com/nl/lake-tahoe/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lake Tahoe in Nevada\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/08/sandy-harbor-beach-lake-tahoe-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Natuurgebieden","post_tags":"Nevada","%_wpb_shortcodes_custom_css%":".vc_custom_1612950540814{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%inline_featured_image%":"0","%_edit_last%":"2","%_edit_lock%":"1693380599:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"32","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"17213","%_yoast_wpseo_focuskw%":"Lake Tahoe","%_yoast_wpseo_metadesc%":"Een van de meren in Nevada is Lake Tahoe. Een zomer- en wintersport bestemming in Amerika. Benieuwd wat je bij Lake Tahoe kunt doen?","%_yoast_wpseo_linkdex%":"47","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"Lake Tahoe, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"39.0968493","%_wpgmp_metabox_longitude%":"-120.0323507","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_primary_category%":"227","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1693380596","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Natuurgebieden","taxonomy=post_tag":"Nevada","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/parken.png"},"id":17210,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/parken.png","name":"Nationale Parken","id":"7","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Great Basin National Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Great Basin National Park in Nevada\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/08/great-basin-national-park-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Great Basin National Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Nevada, Verenigde Staten","location":{"lat":"38.9299798","state":"Nevada","country":"Verenigde Staten","lng":"-114.2633787","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/great-basin-national-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Great Basin National Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Great Basin National Park is een nationaal park dat een redelijk onherbergzaam woestijngebied omvat. Het ligt in de staat Nevada tegen de grens met Utah. Hoewel het grootste deel uit woestijn bestaat, zijn er ook bergtoppen, gletsjers en bossen te vinden in het park. Dit komt doordat je alle ecosystemen vindt in het Great Basin National Park. Het noordelijke deel van het nationale park is het best bereikbaar, hier loopt de Wheeler Peak Scenic Drive die je al rijdend kunt afleggen om uitzichtpunten te bezoeken en wandelingen te maken. Tips voor een bezoek aan het Great Basin National Park.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]476 kilometer vanaf Las Vegas[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">312 km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-paw\"]61 verschillende soorten dieren, 238 verschillende soorten vogels[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Waarom Great Basin?\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Great Basin National Park is onderdeel van Great Basin, ook wel Grote Bekken genoemd. Het gebied ligt tussen de Rocky Mountains en de Sierra Nevada en heeft grotendeels een woestijnklimaat. Het wordt Great Basin genoemd omdat het regenwater dat hier terecht komt niet afgevoerd wordt naar de oceaan, maar in de grondwater bekken terecht komt. Hierdoor is er een grote variatie in flora en fauna te vinden in het gebied. Daarnaast zijn alle soorten eco systemen vertegenwoordigd in het Great Basin National Park.</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Wheeler Scenic Drive in Great Basin National Park\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"De route om te rijden in het park\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"17204\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Facts Great Basin National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Voordat het gebied werd bewoond met mijnwerkers in de 19e eeuw, woonden er verschillende inheemse stammen in het gebied. Door middel van rotstekeningen is te zien dat het park al jaren bewoond werd. In de 19e eeuw liepen verschillende expedities door het Great Basin. Het werd een belangrijke route richting het westen, ook wel de California Trail. Na de vondst van zilver en goud kwamen de eerste mijnbedrijven in de regio met daarbij ook de komst van mijnwerkers en boeren. E\u00e9n daarvan is Absalom Lehman die zijn voedsel verbouwde voor mijnwerkers. Hij was degene die in 1885 de grotten ontdekte die nu zijn naam dragen.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Wat te doen in Great Basin National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Great Basin National Park een relatief klein national park in Amerika. Wil je het park bezoeken? Pak dan het noordelijke deel van het park. Hier vind je de <strong>Wheeler Peak Scenic drive</strong> die je langs uitkijkpunten brengt waar ook wandelroutes beginnen. Het hoogste punt is de Wheeler Peak met 3981 meter. Een andere bezienswaardigheid die de moeite waard is zijn de <strong>Lehman Caves</strong>. Een indrukwekkende grot die je alleen onder begeleiding kunt bezoeken. Bij de <strong>Baker Archeological Sit</strong>e vind je een oude nederzetting van de Fremont indianen uit de 13e eeuw. Van deze groep indianen zijn ook nog sporen te zien bij de <strong>Upper Pictograph Cave</strong>. Een bezienswaardigheid die relatief moeilijk te bezoeken is, is de <strong>Lexington Arch</strong>. Hiervoor moet je 20 kilometer rijden op een onverharde weg en 5,5 kilometer wandelen. Daarnaast is het gebied een Dark Sky Park waardoor sterren kijken hier perfect kan.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten in Great Basin National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In het Great Basin National Park vind je geen mogelijkheden voor hotels of cabins. Hiervoor kun je het beste kiezen voor <a href=\"https://www.booking.com/searchresults.en.html?city=20078834&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=greatbasinnpbaker\" target=\"_blank\" rel=\"noopener\">Baker</a> in Nevada. Mochten hier geen opties meer zijn, dan is <a href=\"https://www.booking.com/searchresults.en.html?city=20078980&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=greatbasinnpely\" target=\"_blank\" rel=\"noopener\">Ely</a> een iets grotere plek om te overnachten. In het park zelf vind je alleen mogelijkheden om te kamperen. Er zijn 5 campgrounds waar je kunt overnachten: Upper Lehman Creek, Lower Lehman Creek, Baker Creek, Grey Cliffs en Wheeler Peak. Ze hebben allemaal toiletten, picknick tafels en campfire grills. Er kunnen 8 mensen slapen, 3 tenten en 2 auto's. Lower Lehman Creek is de enige die het hele jaar geopend is. Reserveringen dienen gemaakt te worden voor Upper Lehman Creek en Wheeler Peak Campgrounds. Voor Grey Cliffs Campground kun je ook reserveren, maar dien je wel minimaal 2 nachten te blijven. Reserveren kan via <a href=\"https://www.recreation.gov/\" target=\"_blank\" rel=\"noopener\">Recreation.Gov</a>.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reisperiode Great Basin National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De beste periode voor een bezoek aan het Great Basin National Park is in de zomermaanden of in de herfst. De warmste maand is juni. Overigens is het mogelijkheid om in deze maanden een zomerse onweersbui te treffen, vaak komende deze aan het einde van de middag.\u00a0 In de wintermaanden kan er sneeuw vallen en koud zijn. De wandelroutes in de lager gelegen delen zijn meestal vanaf de late lente tot begin van de herfst sneeuwvrij.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Trails in Great Basin National Park\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_empty_space height=\"10px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Ontdek het park op \u00e9\u00e9n van de wandelpaden\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"17205\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelen in Great Basin National Park\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]In Great Basin National Park zijn verschillende mogelijkheden om te wandelen. Er zijn 12 trails in het park die je kunt lopen, deze vari\u00ebren van 0,5 kilometer tot 21 kilometer en ook in de moeilijkheid van de trail zitten verschillen. Je hebt makkelijke wandelingen, maar ook wandelingen waar veel ervaring voor vereist is.\u00a0 Een aantal wandelroutes in Great Basin National Park die je kunt lopen:\r\n<ul>\r\n \t<li>Alpine Lakes Loop Trail - 4,4 km - easy</li>\r\n \t<li>Bristlecone Trail - 9,2 km - moderate</li>\r\n \t<li>Bristlecone en Glacier Trail - 15 km - upper moderate</li>\r\n \t<li>Mountain View Nature Trail - 0,5 km - easy</li>\r\n \t<li>Lehman Creek - 10,3 km - moderate</li>\r\n \t<li>Osceaola Ditch - 14,8 km - easy / moderate</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]24/7 en 365 dagen geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: zomer en herfst[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]Gratis[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Wheeler Peak\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_empty_space height=\"10px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Met 3982 meter het hoogste punt van Great Basin National Park\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"17206\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Meer nationale parken\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:4738,4714,4689,4792\"][/vc_column][/vc_row]","post_title":"Great Basin National Park","post_link":"https://www.heyusa.com/nl/great-basin-national-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Great Basin National Park in Nevada\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/08/great-basin-national-park-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Great Basin National Park","post_tags":"Nevada","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%inline_featured_image%":"0","%_edit_lock%":"1692509491:2","%_edit_last%":"2","%_thumbnail_id%":"17203","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Great Basin National Park","%_yoast_wpseo_metadesc%":"In Nevada ligt het Great Basin National Park, een relatief onbekend national park. Tips voor een bezoek aan het Great Basin National Park.","%_yoast_wpseo_linkdex%":"81","%_wpgmp_location_address%":"Nevada, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Nevada","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.9299798","%_wpgmp_metabox_longitude%":"-114.2633787","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%_yoast_wpseo_primary_category%":"232","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1692509530","%_last_editor_used_jetpack%":"classic-editor","%_wp_old_date%":"2023-08-18","taxonomy=category":"Great Basin National Park","taxonomy=post_tag":"Nevada","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""}},"id":17199,"infowindow_disable":false},{"source":"post","title":"Guadalupe Mountains National Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Guadalupe Mountains National Park\" width=\"300\" height=\"230\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/08/Trails-in-Guadalupe-Mountains-National-Park-300x230.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Guadalupe Mountains National Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Dell City, Texas 79847, Verenigde Staten","location":{"lat":"31.92333029999999","city":"Dell City","state":"Texas","country":"Verenigde Staten","lng":"-104.8663109","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/guadalupe-mountains-national-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Guadalupe Mountains National Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De staat Texas heeft een tweetal nationale parken, de bekendste is Big Bend National Park. De andere is het minder bekende Guadalupe Mountains National Park. Het nationale park ligt tegen de grens met New Mexico en bestaat voor het grootste deel uit wildernis. E\u00e9n van de redenen waarom het minder bekend is en bezocht wordt. Er zijn niet veel voorzieningen in het park, maar toch een aantal prachtige natuurlijke bezienswaardigheden die de moeite waard zijn. Tips voor een bezoek aan het Guadalupe Mountains National Park.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]825 kilometer vanaf Dallas[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">349 km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-paw\"]60 verschillende soorten dieren, 289 verschillende soorten vogels[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Eeuwenoude geschiedenis van het Guadalupe Mountains National Park\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Archeologisch bewijs heeft aangetoond dat er al meer dan 10.000 jaar mensen hebben gewoond in het gebied dat nu het Guadalupe Mountains National Park genoemd wordt. Uit aardewerk, rotstekeningen en gevonden manden blijkt dat jagers al jaren actief waren in het gebied en dat er groot wild rondliep. In de 16e eeuw kwamen de eerste Europeanen naar het gebied, de Spanjaarden. Echter vestigden ze zich niet in het gebied, maar de paarden die ze meenamen waren een aanwinst voor de inheemse stammen.</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"El Captain Guadalupe Mountains National Park\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"El Captain variant van Yosemite\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"17169\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Facts Guadalupe Mountains National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Aan het einde van de Amerikaanse Burgeroorlog werden de inheemse stammen uitgedaagd doordat er een nieuwe transportroute door het gebied liep. De Amerikaanse transportroute bracht tussen 1840 en 1850 vele immigranten van oost naar west. De route werd regelmatig doelwit van aanvallen van inheemse stammen, waardoor een Cavalry Regiment het bevel kreeg om deze te stoppen. Twee kampen van Mescalero Apache werden vernietigd en naar Amerikaanse reservaten gedreven. E\u00e9n van de eerste Europese kolonisten in het Guadalupe gebied was Felix McKittrick die in 1870 met vee werkte.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Wat te doen in Guadalupe Mountains National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Hoewel Guadalupe Mountains National Park een relatief onbekende bezienswaardigheid is in Texas, bevat het wel het letterlijke hoogtepunt van de staat. De Guadalupe peak is met 2667 meter hoogte de hoogste plek van Texas. Je kunt deze trouwens ook beklimmen via de Guadalupe Peak Trail. Bij het Pine Springs Visitor Center krijg je meer informatie over het park en tevens kun je er een film kijken. Andere hoogtepunten in het Guadalupe National Park zijn de Frijole Ranch, McKittrick Canyon, Dog Canyon en El Captain. De laatstgenoemde is de Texas variant op de El Captain in <a href=\"https://www.heyusa.com/nl/yosemite-national-park-californie/\">Yosemite National Park</a>. Een massieve rotsblok dat 300 meter boven het landschap uitsteekt. Daarnaast is Guadalupe Mountains NP een walhalla voor vogelliefhebbers, maar liefst 269 verschillende soorten zijn er te vinden.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten in Guadalupe Mountains National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Er zijn het Guadalupe Mountains National Park geen mogelijkheden om te overnachten in hotels, lodges of cabins. De beste plek daarvoor is <a href=\"https://www.booking.com/searchresults.en.html?city=20012027&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=Guadalupecarslbad\" target=\"_blank\" rel=\"noopener\">Carlsbad</a> in New Mexico in het noorden, <a href=\"https://www.booking.com/searchresults.en.html?city=20132048&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=Guadalupevanhorn\" target=\"_blank\" rel=\"noopener\">Van Horn</a> in het zuiden en in het zuidwesten <a href=\"https://www.booking.com/searchresults.en.html?city=20102510&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=Guadalupedellcity\" target=\"_blank\" rel=\"noopener\">Del City</a>, beiden in Texas. In het park vind je alleen mogelijkheden om te overnachten op \u00e9\u00e9n van de twee campings: Pine Springs en Dog Canyon. Beiden zijn simpele campings, maar wel met waterfaciliteiten (geen douche) en toiletten. De campings kunnen gereserveerd worden via <a href=\"https://www.recreation.gov/\" target=\"_blank\" rel=\"noopener\">Recreation.gov</a>.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reisperiode Guadalupe Mountains National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De beste periode voor een bezoek aan het Guadalupe Mountains National Park is de herfst. In de zomer kan het erg warm zijn in het gebied. In de herfst kun je de verandering van de bladeren meemaken. Iets dat overigens redelijk wat mensen trekt, dus het kan er druk zijn.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Trails in Guadalupe Mountains National Park\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Ontdek het park op een van de wandelpaden\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"17171\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelen in Guadalupe Mountains National Park\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]Guadalupe Mountains National Park kun je prima wandelend verkennen. Er zijn meer dan 125 kilometer aan trails te vinden in het park.\u00a0 Je kunt er makkelijke wandelingen maken, maar ook meerdaagse wandelingen. Een aantal wandelingen die je kunt maken zijn:\r\n<ul>\r\n \t<li>Smith Spring Loop - 3,7 km</li>\r\n \t<li>Devils Hall Trail - 6,1 km</li>\r\n \t<li>Guadalupe Peak Trail - 13,6 km</li>\r\n \t<li>Pinery Trail - 2,4 km</li>\r\n \t<li>El Captain / Salt Basin Overlook Trail - 18 km</li>\r\n \t<li>McKittrick Canyon Trail - 11 km</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]24/7 en 365 dagen geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: herfst[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]Standard Entrance Pass: $10\r\nAnnual Entrance Pass: $35[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Guadalupe Peak\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"De hoogste berg van Texas\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"17170\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Meer nationale parken\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:4738,4714,4689,4792\"][/vc_column][/vc_row]","post_title":"Guadalupe Mountains National Park","post_link":"https://www.heyusa.com/nl/guadalupe-mountains-national-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Guadalupe Mountains National Park\" width=\"300\" height=\"230\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/08/Trails-in-Guadalupe-Mountains-National-Park-300x230.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Guadalupe Mountains National Park","post_tags":"Texas","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%inline_featured_image%":"0","%_edit_lock%":"1692261357:2","%_edit_last%":"2","%_thumbnail_id%":"17179","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Guadalupe Mountains National Park","%_yoast_wpseo_metadesc%":"In Texas ligt het Guadalupe Mountains National Park, een relatief onbekende bezienswaardigheid Tips voor een bezoek aan het Guadalupe National Park.","%_yoast_wpseo_linkdex%":"82","%_wpgmp_location_address%":"Dell City, Texas 79847, Verenigde Staten","%_wpgmp_location_city%":"Dell City","%_wpgmp_location_state%":"Texas","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"31.92333029999999","%_wpgmp_metabox_longitude%":"-104.8663109","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_primary_category%":"231","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1692261302","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Guadalupe Mountains National Park","taxonomy=post_tag":"Texas","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""}},"id":17156,"infowindow_disable":false},{"source":"post","title":"Grand Canyon helikoptervlucht","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Helikoptervlucht in de Grand Canyon\" width=\"300\" height=\"225\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/08/grand-canyon-helikoptervlucht-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Grand Canyon helikoptervlucht</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"Een zwevend platform van glas boven de Grand Canyon, durf jij het aan?","address":"Grand Canyon, Arizona 86052, Verenigde Staten","location":{"lat":"36.09976309999999","state":"Arizona","country":"Verenigde Staten","lng":"-112.1124846","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/grand-canyon-helikoptervlucht/","zoom":12,"extra_fields":{"post_excerpt":"Een zwevend platform van glas boven de Grand Canyon, durf jij het aan?","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"30px\"][vc_custom_heading text=\"Grand Canyon helikoptervlucht\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De Grand Canyon, misschien wel \u00e9\u00e9n van de mooiste plekken om een helikoptervlucht te boeken. Het is een fantastische ervaring om de Grand Canyon te zien vanuit een helikopter. Ontdek de Colorado River die kronkelt door de Grand Canyon vanaf een hoogte van meer dan 1000 meter.\u00a0 Er zijn verschillende helikoptervluchten mogelijk in het Grand Canyon National Park. Bekijk hier de opties voor het boeken van een helikoptervlucht over de Grand Canyon.[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-arrows-v\"]1000 meter hoogte[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]$230-$365 per persoon[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612949537564{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Over het Grand Canyon National Park\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Een bezoek aan de Grand Canyon is \u00e9\u00e9n van de mooiste ervaringen in Amerika om mee te maken. Het landschap is overweldigend om te zien. Sinds 1979 behoort de Grand Canyon tot werelderfgoed en is het \u00e9\u00e9n van de zeven wereldwonderen. Uitkijken over de enorme canyon is op iedere plek in het park weer anders, iedere keer zie je weer iets spectaculairs voorbij komen. Laat staan wanneer je er met een helikopter overheen vliegt. Een ervaring om nooit weer te vergeten!</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Op 1000 meter boven de Grand Canyon vliegen\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1.4\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Durf jij het aan?\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"17064\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row disable_element=\"yes\"][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tickets voor The Grand Canyon Skywalk\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Je kunt voor een bezoek aan de Skywalk verschillende tickets kopen. Zo kun je een los ticket aanschaffen en zelf de rit maken richting de Grand Canyon Skywalk, maar er zijn ook diverse opties voor tours richting de Skywalk die aan te raden zijn.\r\n\r\n[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fgrandcanyonwest.com%2F\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>808 Eagle Point Road, Peach Springs Arizona</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Dagelijks van 08.00 - 18.00 uur, laatste tickets worden rond 15.30 uur verkocht</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][ultimate_heading main_heading=\"Helikoptervlucht over de Grand Canyon boeken\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Bekijk de verschillende opties voor helikoptervluchten inclusief de prijzen voor een helikoptervlucht in de Grand Canyon</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Helikoptervlucht over de West Rim van de Grand Canyon\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][ultimate_heading main_heading=\"Vanaf \u20ac236\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_margin=\"margin-top:5px;margin-bottom:5px;\"][/ultimate_heading][vc_column_text]Met een helikopter vliegen over de West Rim van de Grand Canyon en ook nog eens op de bodem van de Grand Canyon staan? Dan is <a href=\"https://www.getyourguide.nl/kingman-l98322/arizona-helikopter-en-landingstour-grand-canyon-west-rim-t291365/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=helikoptervluchtgrandcanyonwestrimintekst\" target=\"_blank\" rel=\"noopener\">deze vlucht</a> geschikt voor jou. Eerst bekijk je de Grand Canyon vanaf ongeveer 1000 meter hoogte, daarna daal je af naar de landingsplaats op slechts 90 meter van de Colorado River. Hier heb je 20 minuten de tijd om foto's te maken voordat je terugvliegt naar West Rim Airport.[/vc_column_text][ultimate_heading main_heading=\"Praktische informatie\" heading_tag=\"div\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_column_text]<b>Handig:</b>\u00a0 Vergeet je camera niet mee te nemen\r\n<b>Vertrek</b>: Grand Canyon West Airport\r\n<b>Let op</b>: Bij de helikoptervlucht is het gewicht belangrijk, ben je zwaarder dan 135 kilo dien je 2 plekken te kopen. Kinderen ouder dan 2 jaar moeten een zitplaats kopen. Je hebt daarnaast een toegangsbewijs nodig voor de Grand Canyon west[/vc_column_text][ult_buttons btn_title=\"Boek deze tour\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fkingman-l98322%2Farizona-helikopter-en-landingstour-grand-canyon-west-rim-t291365%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26cmp%3Dhelikoptervluchtgrandcanyonwestrimbutton|title:Boek%20deze%20tour|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Helikoptervlucht over de South Rim van de Grand Canyon\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][ultimate_heading main_heading=\"Vanaf \u20ac290\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_margin=\"margin-top:5px;margin-bottom:5px;\"][/ultimate_heading][vc_column_text]Met deze <a href=\"https://www.getyourguide.nl/grand-canyon-village-l117465/grand-canyon-dancer-helikoptertour-vanuit-south-rim-t7807/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=helikoptervluchtgrandcanyonsouthrimintekst\" target=\"_blank\" rel=\"noopener\">helikoptervlucht</a> vlieg je over de zuidelijke rand van de Grand Canyon en kun je onder andere het Kaibab National Forest zien vanuit de lucht. Je vliegt via de Tower of Ra naar het noorden om de Dragon Corridor te bekijken. Dit is het diepste deel van de Grand Canyon. In 25 minuten zie je prachtige rotslagen van de Grand Canyon vanuit de lucht.[/vc_column_text][ultimate_heading main_heading=\"Praktische informatie\" heading_tag=\"div\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_column_text]<b>Duur:</b>\u00a0 25 minuten\r\n<b>Vertrek</b>: 107 Corsair Dr., Grand Canyon\r\n<b>Let op: </b>Kom minimaal 40 minuten van te voren bij de terminal, passagiers die meer dan 135 kilo wegen moeten 2 stoelen kopen.[/vc_column_text][ult_buttons btn_title=\"Boek deze tour\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fgrand-canyon-village-l117465%2Fgrand-canyon-dancer-helikoptertour-vanuit-south-rim-t7807%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26cmp%3Dhelikoptervluchtgrandcanyonsouthrimbutton|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Helikoptervlucht Grand Canyon vanuit Las Vegas over de West Rim\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][ultimate_heading main_heading=\"Vanaf \u20ac364\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_margin=\"margin-top:5px;margin-bottom:5px;\"][/ultimate_heading][vc_column_text]Ben je in Las Vegas en wil je een helikoptervlucht maken over de Grand Canyon? Dan is <a href=\"https://www.getyourguide.nl/las-vegas-l58/grand-canyon-helikopteravontuur-west-rim-vlucht-t438597/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=helikoptervluchtgrandcanyonlasvegaswestrimintekst\" target=\"_blank\" rel=\"noopener\">deze vlucht</a> een aanrader. Je wordt opgehaald met een busje bij je hotel aan de Las Vegas Strip om vervolgens een fotostop te maken bij de Hoover Dam Bypass Bridge. Daarna stap je aan boord van de helikopter om de westrand van de Grand Canyon te bekijken terwijl je onder je de Colorado River ziet stromen. Na een vlucht van 20 minuten kom je terug op de ranch voor een lunch. Je kunt eventueel je trip nog uitbreiden met een ritje per paard of ATV.[/vc_column_text][ultimate_heading main_heading=\"Praktische informatie\" heading_tag=\"div\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_column_text]<b>Duur: </b>7,5-8 uur\u00a0<b>\r\nHandig:</b>\u00a0 Ophalen bij de meeste hotels, lunch inbegrepen\r\n<b>Vertrek</b>: Eigen hotel\r\n<b>Let op</b>: Personen zwaarder dan 135 kilo moeten een extra stoel kopen[/vc_column_text][ult_buttons btn_title=\"Boek deze tour\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Flas-vegas-l58%2Fgrand-canyon-helikopteravontuur-west-rim-vlucht-t438597%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26cmp%3Dhelikoptervluchtgrandcanyonlasvegaswestrimbutton|title:Boek%20deze%20tour|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"95%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Opties helikoptervluchten in de Grand Canyon\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1.6\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Bij sommige vluchten kun je landen in de Grand Canyon\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"17065\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Andere artikelen over de Grand Canyon\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:3223,3208,1971,13179\"][/vc_column][/vc_row]","post_title":"Grand Canyon helikoptervlucht","post_link":"https://www.heyusa.com/nl/grand-canyon-helikoptervlucht/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Helikoptervlucht in de Grand Canyon\" width=\"300\" height=\"225\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/08/grand-canyon-helikoptervlucht-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Grand Canyon National Park","post_tags":"Arizona","%_wpb_shortcodes_custom_css%":".vc_custom_1612949537564{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"10","%_edit_lock%":"1713603552:10","%_wpb_vc_js_status%":"true","%post-primary-category%":"65","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"17063","%_yoast_wpseo_focuskw%":"Grand Canyon helikoptervlucht","%_yoast_wpseo_title%":"Grand Canyon helikoptervlucht %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Grand Canyon helikoptervlucht is een van de gaafste ervaringen in de buurt van de Grand Canyon. Stap in de helikopter voor een fantastisch uitzicht!","%_yoast_wpseo_linkdex%":"75","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"Grand Canyon, Arizona 86052, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Arizona","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"36.09976309999999","%_wpgmp_metabox_longitude%":"-112.1124846","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_primary_category%":"33","%_yoast_indexnow_last_ping%":"1713603449","%_last_editor_used_jetpack%":"classic-editor","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","taxonomy=category":"Grand Canyon National Park","taxonomy=post_tag":"Arizona","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":17060,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"RiseNY op Times Square","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"De vluchtsimulator attractie RiseNY op Times Square\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/07/riseny-times-square-manhattan-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">RiseNY op Times Square</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"160 W 45th St, New York, NY 10036, Verenigde Staten","location":{"lat":"40.75762069999999","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.98517609999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/riseny-op-times-square/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Vlieg over New York\" font_size=\"55\" line_height=\"60\" font_color=\"#b34a4c\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][vc_custom_heading text=\"Ontdek RiseNY op Times Square\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><a href=\"https://www.getyourguide.nl/new-york-l59/new-york-city-riseny-experience-ticket-t369796/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=heyusa-website-riseny\" target=\"_blank\" rel=\"noopener\">RiseNY</a> op Times Square in New York is d\u00e9 nieuwste attractie en ervaring in Manhattan. Je ontdekt de stad vanuit een heel ander perspectief: dat van een vogel. Tijdens <a href=\"https://www.getyourguide.nl/new-york-l59/new-york-city-riseny-experience-ticket-t369796/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=heyusa-website-riseny\" target=\"_blank\" rel=\"noopener\">een unieke vlucht</a> vlieg je langs de verschillende attracties en bezienswaardigheden van New York. Tijdens deze vlucht ervaar je effecten als wind, water en geur waardoor de vlucht n\u00f3g realistischer wordt. Een vergelijkbare attractie kun je vinden in Walt Disney World: Soarin' in Epcot.</p>\r\n[/vc_column_text][ult_buttons btn_title=\"TICKETS\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fnew-york-l59%2Fnew-york-city-riseny-experience-ticket-t369796%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26cmp%3Dheyusa-website-riseny|title:RiseNY%20Tickets|target:_blank\" btn_align=\"ubtn-center\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"95%\"][/vc_column][/vc_row][vc_row content_placement=\"middle\" css=\".vc_custom_1690819192256{background-color: #000000 !important;}\"][vc_column][vc_empty_space height=\"350px\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Unieke attracties in de Big Apple\" font_size=\"55\" line_height=\"60\" font_color=\"#ffffff\"][vc_custom_heading text=\"Vlieg als een vogel over New York\" font_container=\"tag:h3|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"90\" image=\"16971\"][fullwidth_row content_width=\"100%\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1688977070542{background-color: #f7f7f7 !important;}\"][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"95%\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][vc_custom_heading text=\"Vogelvlucht over New York met RiseNY\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">De wind door je haren, waterspetters en de geuren van New York City. Tijdens deze innovatieve vluchtsimulatie vlieg je over New York. Het enorme videoscherm van RiseNY in combinatie met je bewegende stoel doet je helemaal vergeten dat dit niet \u00e9cht is. Je neemt plaats in een stoel en vliegt door de stad. Een 4DX IMAX-ervaring met wind, mist, geur, water in een bewegende stoel.</p>\r\n[/vc_column_text][ult_buttons btn_title=\"TICKETS\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fnew-york-l59%2Fnew-york-city-riseny-experience-ticket-t369796%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26cmp%3Dheyusa-website-riseny|title:RiseNY%20Tickets|target:_blank\" btn_align=\"ubtn-center\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space][/vc_column][/vc_row][vc_row content_placement=\"middle\" css=\".vc_custom_1690817072879{background-color: #000000 !important;}\"][vc_column][vc_empty_space height=\"350px\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Memorabilia van televisie, film, mode, muziek &amp; Broadway\" font_size=\"55\" line_height=\"60\" font_color=\"#ffffff\"][vc_custom_heading text=\"Ontdek de hoogtepunten van New York in RiseNY\" font_container=\"tag:h3|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" image=\"16972\"][fullwidth_row content_width=\"100%\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1690819285317{background-color: #f2f2f2 !important;}\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"THEMARUIMTES\" font_container=\"tag:h3|font_size:25|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Voordat je RiseNY vlucht begint ontdek je New York via zeven verschillende zalen die elk een eigen thema hebben. Van televisie tot Broadway, film, mode, muziek en de skyline van New York. In deze mini-exposities kom je meer te weten over deze thema's maar vind je ook beroemde iconen van New York. Zoals de bank van de televisieserie Friends, op de set van de late night show en kostuums uit musicals.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Introductiefilm ingesproken door acteur Jeff Goldblum\" font_container=\"tag:h3|font_size:25|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Voordat je RiseNY avontuur begint, start je in de nagebouwde metrohalte City Hall van New York waar je een korte film krijgt te zien van de bekroonde documentairemaker Ric Burns. De film wordt verteld door acteur Jeff Goldblum, bekend van Jurassic Park.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Ideaal voor tijdens een regenachtige dag\" font_container=\"tag:h3|font_size:25|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een bezoek aan RiseNY is een ideale activiteit tijdens een regenachtige dag in New York. Ook voor mensen die hoogtevrees hebben, kunnen via deze simulatie t\u00f3ch over New York vliegen. Je kunt hier een uurtje New York op een andere manier beleven, even vliegen over de stad \u00e9n het licht centraal op Times Square.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"100%\"][/vc_column][/vc_row][vc_row content_placement=\"middle\" css=\".vc_custom_1690817072879{background-color: #000000 !important;}\"][vc_column][vc_empty_space height=\"350px\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ingesproken door acteur Jeff Goldblum\" font_size=\"55\" line_height=\"60\" font_color=\"#ffffff\"][vc_custom_heading text=\"Ontdek New York in een replica van metrohalte City Hall\" font_container=\"tag:h3|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" image=\"16974\"][fullwidth_row content_width=\"100%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"100%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Tickets RiseNY op Times Square\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-location-arrow\"]160 West 45th Street (Times Square)[/ultimate_icon_list_item][/ultimate_icon_list][vc_column_text]In een notendop een ontzettend leuke attractie! Ideaal tijdens slecht weer, maar zeker \u00f3\u00f3k de moeite als je wat langer in de buurt van Times Square wilt blijven. De <a href=\"https://www.getyourguide.nl/new-york-l59/new-york-city-riseny-experience-ticket-t369796/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=heyusa-website-riseny\">RiseNY simulatie</a> is indrukwekkend, met een 180 graden 8K scherm met een doorsnede van 12 meter waar je op 9 meter hoogte vliegt.[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-arrows-v\"]12 meter hoog scherm[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-plane\"]Je 'vliegt' op 9 meter hoogte[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf \u20ac32 per persoon[/ultimate_icon_list_item][/ultimate_icon_list][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"5/6\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"RiseNY is een leuke attractie om samen met je kinderen te doen. Maar let op, kinderen moeten minimaal 1 meter groot zijn om te mogen meevliegen.\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:100%20light%20regular%3A100%3Anormal\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fnew-york-l59%2Fnew-york-city-riseny-experience-ticket-t369796%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26cmp%3Dheyusa-website-riseny|title:Bestel%20je%20tickets%20voor%20RiseNY|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1620887540936{background-color: #dadada !important;}\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][ultimate_heading main_heading=\"Veelgestelde vragen over RiseNY\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:800;\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][vc_toggle title=\"Wat kost een ticket voor RiseNY\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]Je hebt tickets vanaf 30+ euro[/vc_toggle][vc_toggle title=\"Wat is de beste tijd om RiseNY te bezoeken?\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]Tijdens de ochtend is RiseNY het minst druk.[/vc_toggle][vc_toggle title=\"Hoe lang duurt een bezoek aan RiseNY\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]Je bent ongeveer \u00e9\u00e9n uur kwijt voor een bezoek aan RiseNY[/vc_toggle][vc_toggle title=\"Wat is RiseNY op Times Square\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]RiseNY is een vluchtsimulator attractie vergelijkbaar met Soarin' in Epcot, Disney World. \u00d3\u00f3k in Las Vegas kun je vliegen in 'FlyOver' een vergelijkbare attractie als RiseNY.[/vc_toggle][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"80%\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:10251,1559,506,298\"][/vc_column][/vc_row]","post_title":"RiseNY op Times Square","post_link":"https://www.heyusa.com/nl/riseny-op-times-square/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"De vluchtsimulator attractie RiseNY op Times Square\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/07/riseny-times-square-manhattan-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden New York","post_tags":"","%_last_editor_used_jetpack%":"classic-editor","%_edit_lock%":"1711615483:2","%_edit_last%":"1","%_hide_featured%":null,"%_wpgmp_location_address%":"160 W 45th St, New York, NY 10036, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.75762069999999","%_wpgmp_metabox_longitude%":"-73.98517609999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1690819192256{background-color: #000000 !important;}.vc_custom_1688977070542{background-color: #f7f7f7 !important;}.vc_custom_1690817072879{background-color: #000000 !important;}.vc_custom_1690819285317{background-color: #f2f2f2 !important;}.vc_custom_1690817072879{background-color: #000000 !important;}.vc_custom_1620887540936{background-color: #dadada !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}","%_yoast_wpseo_primary_category%":"14","%_yoast_indexnow_last_ping%":"1690882424","%_yoast_wpseo_focuskw%":"RiseNY op Times Square","%_yoast_wpseo_metadesc%":"RiseNY op Times Square in New York is een simulatie attractie waarbij je vliegt over de stad. \u2714 Koop je RiseNY tickets hier!","%_yoast_wpseo_linkdex%":"73","%_thumbnail_id%":"16976","taxonomy=category":"Bezienswaardigheden New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":16955,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Madame Tussauds in Los Angeles","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Madame Tussauds Los Angeles\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/07/madame-tussauds-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Madame Tussauds in Los Angeles</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"6933 Hollywood Blvd, Los Angeles, CA 90028, Verenigde Staten","location":{"lat":"34.1017225","city":"Los Angeles","state":"California","country":"Verenigde Staten","lng":"-118.3415065","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/madame-tussauds-in-los-angeles/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Madame Tussauds in New York bezoeken\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Hoewel je in Los Angeles de kans hebt om beroemdheden op straat tegen te komen, is de plek om beroemdheden te spotten is natuurlijk bij Madame Tussauds. Natuurlijk gaat het hier om hun wassen beeld versie, toch blijft Madame Tussauds een leuke activiteit voor jong en oud. Bekijk hoeveel beroemdheden jij herkent in het Madame Tussauds en bestel alvast je <a href=\"https://www.getyourguide.nl/hollywood-l96196/hollywood-tickets-voor-madame-tussauds-t10047/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=madametussaudslosangelesintrotekst\" target=\"_blank\" rel=\"noopener\">tickets online</a>!</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf <span class=\"sticky-booking-assistant__price\" data-v-35e2752c=\"\">\u20ac3o</span>[/ultimate_icon_list_item][/ultimate_icon_list][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fhollywood-l96196%2Fhollywood-tickets-voor-madame-tussauds-t10047%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26cmp%3Dmadametussaudslosangelesbuttonboven|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612949537564{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Madame Tussauds\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Op 3 verdiepingen kun je selfies maken met de wassen beeld versie van vele beroemdheden. Sinds 2009 kun je 125 verschillende wassen beelden bekijken in Madame Tussauds op de Hollywood Boulevard in Los Angeles. De eerste twee beroemdheden op de locatie in Los Angeles waren Beyonce en Jamie Foxx. Ooit werd Madame Tussauds bedacht door Maria Tussaud, die in 1778 haar eerste beeld maakte. Een aantal jaren erna werden haar wassen beelden tentoongesteld in Engeland. Sinds haar overlijden zijn de beelden te bekijken in Madame Tussauds in Londen, de locatie van het huidige museum in de stad. Sinds de opening in London zijn er meer dan 25 vestigingen van Madame Tussauds geopend wereldwijd.</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Deze ruimtes mag je niet missen in Madame Tussauds in New York\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"16950\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"A- list Party\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Ga langs de red carpet staan om je favoriete celebrities te zien die voor je poseren alsof jij de paparazzi bent. Sterren als Dwayne Johnson, Kylie Jenner, Angelina Jolie, Meryl Streep en Ariana Grande komen allemaal voorbij.</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"16941\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Spirit of Hollywood\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Ontdek de Golden Age of Cinema in Madame Tussauds in Los Angeles. Verschillende Hollywood genre worden uitgelicht in dit deel van het museum. Ga op de foto met sterren als Marilyn Monroe, Charlie Chaplin, Judy Garland en Fred Astaire.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"16942\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Music\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Ontmoet de grootste muzikale sterren van afgelopen jaren in de Music Room. Ga op de foto met de King of Pop Michael Jackson, bekijk Little Monsters van Lady Gaga en natuurlijk kunnen sterren als Beyonce, Shakira en Lil Nas X niet ontbreken.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Spot verschillende beroemdheden\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ga op de foto met Dwayne ``The Rock`` Johnson\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"16922\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tickets voor Madame Tussauds\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Voor je bezoek aan Madame Tussauds kun je <a href=\"https://www.getyourguide.nl/hollywood-l96196/hollywood-tickets-voor-madame-tussauds-t10047/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=madametussaudslosangelestekstticket\" target=\"_blank\" rel=\"noopener\">online een ticket aanschaffen</a>. Zo heb je gegarandeerd toegang tot het museum. Voor de Marvel Universe 4D experience dien je een extra ticket aan te schaffen.[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fhollywood-l96196%2Fhollywood-tickets-voor-madame-tussauds-t10047%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26cmp%3Dmadametussaudslosangelesbuttononder|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"1/2\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>6933 Hollywood Blvd</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Maandag t/m zondag: 10.00 tot 20.00 uur\r\nMet uitzondering van dinsdag: 10.00-18.00 uur</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1620887540936{background-color: #dadada !important;}\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][ultimate_heading main_heading=\"Veelgestelde vragen over Madame Tussauds\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:800;\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][vc_toggle title=\"Wat kost een ticket voor Madame Tussauds\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]Je hebt tickets vanaf 30 euro[/vc_toggle][vc_toggle title=\"Wat is de beste tijd om Madame Tussauds te bezoeken?\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]De beste tijd om Madame Tussauds te bezoeken is in de vroege morgen. Op dat tijdstip is het rustiger dan midden op de dag.[/vc_toggle][vc_toggle title=\"Hoe lang duurt een bezoek aan Madame Tussauds?\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]Je bent ongeveer 1,5 uur kwijt voor een bezoek aan Madame Tussauds[/vc_toggle][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"80%\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Amerikaanse popsterren\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ariane Grande\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"16949\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Los Angeles\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:-10251,-1559,-506,-298,8299,5121,12865,5003\"][/vc_column][/vc_row]","post_title":"Madame Tussauds in Los Angeles","post_link":"https://www.heyusa.com/nl/madame-tussauds-in-los-angeles/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Madame Tussauds Los Angeles\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/07/madame-tussauds-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Los Angeles","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1612949537564{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1620887540936{background-color: #dadada !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%inline_featured_image%":"0","%_edit_last%":"2","%_edit_lock%":"1690819691:1","%_wpb_vc_js_status%":"true","%post-primary-category%":"52","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"16943","%_yoast_wpseo_focuskw%":"Madame Tussauds in Los Angeles","%_yoast_wpseo_title%":"Madame Tussauds in Los Angeles%%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een leuke attractie is Madame Tussauds in Los Angeles. Het wassenbeelden museum is de plek om beroemdheden te spotten en selfies te maken. Koop hier je tickets.","%_yoast_wpseo_linkdex%":"77","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Tickets Madame Tussauds\"]","%_wpgmp_location_address%":"6933 Hollywood Blvd, Los Angeles, CA 90028, Verenigde Staten","%_wpgmp_location_city%":"Los Angeles","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"34.1017225","%_wpgmp_metabox_longitude%":"-118.3415065","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_primary_category%":"52","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1690807112","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","%post_via%":[{"title":"Foto's \u00a9 Madame Tussauds (Madame Tussauds USA) /  Merlin Entertainments Ltd","post_source_url":"https://www.madametussauds.com/"}],"taxonomy=category":"Bezienswaardigheden Los Angeles","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":16928,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Palm Beach &#038; West Palm Beach in Florida","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"West palm Beach\" width=\"300\" height=\"225\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/07/west-palm-beach-1-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Palm Beach &#038; West Palm Beach in Florida</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Sanibel Island, Florida, Verenigde Staten","location":{"lat":"26.4433972","state":"Florida","country":"Verenigde Staten","lng":"-82.1115119","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/palm-beach-florida/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"75px\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"25px\"][vc_empty_space height=\"25px\"][ultimate_heading main_heading=\"Palm Beach &amp; West Palm Beach\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]<strong>Palm Beach en West Palm Beach in Florida zijn twee plekken die goed te combineren zijn. Het eiland Palm Beach ligt voor de kust van West Palm Beach en is te bereiken via een van de 3 bruggen. West Palm Beach wordt gezien als het St. Tropez van Florida, dat geldt ook enigszins voor Palm Beach met het pluspunt dat Palm Beach stranden heeft, West Palm Beach niet. Omdat beide plekken goed samen te bezoeken zijn, tips voor zowel Palm Beach als West Palm Beach.\r\n</strong>[/vc_column_text][vc_empty_space height=\"75px\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen in Palm Beach\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Palm Beach is \u00e9\u00e9n van de postcodes in Amerika waarvan je weet dat er veel rijke mensen wonen, net zoals 90210 in Los Angeles. Het is de favoriete bestemming van vele rijke overwinteraars. Op slechts 2 uur van Miami, of maar 1 uur met de <a href=\"https://www.gobrightline.com/\" target=\"_blank\" rel=\"noopener\">Brightline</a> trein, is Palm Beach een al glitter en glamour. Toch hoef je niet rijk en beroemd te zijn om te genieten van Palm Beach. Je hebt er prachtige stranden en natuur, kunt er winkelen, musea bezoeken en dineren bij fijne restaurants, genoeg mogelijkheden voor iedereen.</p>\r\n[/vc_column_text][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/4\"][ultimate_heading main_heading=\"Mar a Lago\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Mar-A-Lago, voor velen bekend vanwege oud president Trump. Het huis is sinds 1985 in zijn bezit. Hiervoor werd de luxueuze villa door de eigenaren aan de Amerikaanse overheid geschonken als toevluchtsoord voor presidenten. Het werd nooit voor dit doel gebruikt totdat Trump het kocht. Naast Trump brachten ook vele andere beroemdheden hun tijd door in Mar-A-Lago. In 1994 gingen Michael Jackson en Lisa Marie Presley op huwelijksreis in de vila.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][ultimate_heading main_heading=\"Stranden van Palm Beach\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Met een enorme kustlijn heeft Palm Beach veel te bieden voor strandliefhebbers. Enkele tips voor mooie stranden zijn:\r\n- Lake Worth Beach - families\r\n- Peanut Island - party\r\n- Delray Beach - lifeguards\r\n- John D. MacArthur State Park - families en natuurliefhebbers\r\n- Juno Beach - locals</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][ultimate_heading main_heading=\"John D. Macarthur Beach State Park\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Het John D. MacArthur Beach State Park geeft natuurliefhebbers de mogelijkheid om rondom Palm Beach de natuur in te gaan. Het is het enige staatspark in Palm Beach County en is 436 hectare groot. Natuurlijk kunnen ongerepte stranden, duinen en veel groen niet ontbreken. Je hebt mogelijkheden om wilde dieren te zien, waaronder bedreigde dieren. Een leuke manier om het park te verkennen, is al snorkelend.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][ultimate_heading main_heading=\"Flagler Museum\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Een van de belangrijkste mensen in de ontwikkeling van Palm Beach is Henry Morrison Flagler. De medeoprichter van Standard Oil die het eiland als een perfect toevluchtsoord zag voor zijn rijke en beroemde vrienden. Door het aanleggen van de spoorlijn, op zijn initiatief, werd Palm Beach groot. In het Flagler Museum, dat in het winterhuis is gevestigd dat hij zijn vrouw cadeau gaf in 1902, vind je allerlei artefacten uit het leven van Flagler. Het museum beschikt over 75 kamers en herbergt onder andere zijn priv\u00e9-trein wagon.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Palm Beach\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Tal van mooie stranden\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"16576\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Wat je niet mag missen in West Palm Beach\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">West Palm Beach is een levendige stad in Florida met een luxe imago. Er hangt een relaxte sfeer, het is er lekker weer het hele jaar door en er zijn genoeg dingen om te doen. Zowel voor natuur-, cultuur- als shop liefhebbers zijn er tal van dingen om te ondernemen. Tips voor het verkennen van West Palm Beach.</p>\r\n[/vc_column_text][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/4\"][ultimate_heading main_heading=\"Antique Row\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In West Palm Beach vind je een unieke plek voor antiekliefhebbers; Antique Row. Je vindt hier meer dan 40 antieke winkels. Ze liggen allemaal op loopafstand van elkaar waardoor het makkelijk is om ze te bezoeken. Denk aan antiek uit de 17e tot 20e eeuw, kunst, vintage en moderne meubels, er is van alles te vinden in Antique Row.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][ultimate_heading main_heading=\"Northwood Village\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Een leuke wijk in West Palm Beach is Northwood Village. Vele gebouwen in Northwood Village dateren uit 1920 en 1930 en daardoor heeft de wijk een eigen karakter en charme. Je vindt er veel winkels, restaurants en galerie\u00ebn. Daarnaast worden er gedurende het hele jaar verschillende evenementen georganiseerd.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][ultimate_heading main_heading=\"West Palm Beach Zoo\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In het Dreher Park in West Palm Beach ligt de West Palm Beach Zoo, een dierentuin met meer dan honderden dieren. De plek om tijgers, otters, schildpadden, maar ook Mexicaanse reuzenspinnen te zien. Een ideale gezinsactiviteit om te doen in West Palm Beach. West Palm Beach Zoo werd opgericht in 1957 en is sindsdien een belangrijke attractie van de stad. Het is gericht op het beschermen van bedreigde diersoorten en natuurbehoud. Neem ongeveer 1-2 uur de tijd voor een bezoek aan de dierentuin.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][ultimate_heading main_heading=\"Rosemary Square\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Een goede manier om kennis te maken met West Palm Beach is door een bezoek te brengen aan Rosemary Square. Het centraal gelegen plein in de stad staat vol met gebouwen in mediterrane stijl, palmbomen en is omringd door sfeervolle straten. Hier vind je tal van leuke boetieks, caf\u00e9s en restaurants.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" thb_row_padding=\"true\" thb_column_padding=\"true\" content_placement=\"middle\"][vc_column width=\"1/2\"][vc_row_inner][vc_column_inner width=\"5/6\"][vc_custom_heading text=\"Manatee Lagoon\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" heading=\"Spot de manatee\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][vc_column_text]\r\n<p style=\"text-align: left;\">In Florida heb je verschillende plekken om de unieke inwoner van het water te zien: de <a href=\"https://www.heyusa.com/nl/manatees-florida/\">manatee</a>. De manatee, ook wel zeekoe, is een uniek dier in Florida die je het beste kunt zien in de wintermaanden. Iets ten noorden van West Palm Beach verzamelden manatees in de buurt van de Florida Power &amp; Light faciliteit. Vanwege de warm waterstroom een ideale plek voor deze dieren. Vanaf deze plek kun je de manatees perfect zien zwemmen.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][thb_image retina=\"retina_size\" full_width=\"true\" image=\"15365\"][/thb_image][/vc_column][/vc_row][vc_row thb_full_width=\"true\" thb_row_padding=\"true\" thb_column_padding=\"true\" content_placement=\"middle\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][thb_image retina=\"retina_size\" full_width=\"true\" image=\"16701\"][/thb_image][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/2\"][vc_row_inner][vc_column_inner width=\"5/6\"][vc_custom_heading text=\"Peanut Island\" font_container=\"tag:h3|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" heading=\"Tropisch paradijs\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][vc_column_text]\r\n<p style=\"text-align: left;\">Tussen West Palm Beach en Palm Beach vind je het eiland Peanut Island. Het 79 hectare grote eiland ligt in de monding van Lake Worth Inlet. Een tropisch paradijs met ongerepte witte stranden, palmbomen en helder water dat uitnodigt om te watersporten en te snorkelen. Je kunt er tropische vissen zien, zeesterren en misschien zelfs manatees. Op het eiland kun je de nucleaire bunker bezoeken die John F. Kennedy bouwde tijdens de Koude Oorlog.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"West Palm Beach\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Stad met een luxe imago\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"16578\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1689956280731{padding-top: 50px !important;padding-bottom: 50px !important;background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2021/08/all-day-usa-background.gif?id=8408) !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][heyusa_heading tag=\"div\" heading=\"Handige info van de redactie\" font_size=\"43\" line_height=\"45\" font_color=\"#b34a4c\"][vc_custom_heading text=\"Essenti\u00eble tips voor reizen naar Palm Beach:\" font_container=\"tag:h3|font_size:25|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][vc_row_inner box_shadow=\"large-shadow\" css=\".vc_custom_1689955486087{background-color: #ffffff !important;border-radius: 10px !important;}\"][vc_column_inner][vc_empty_space height=\"25px\"][ultimate_icon_list icon_size=\"65\" icon_margin=\"10\"][ultimate_icon_list_item icon_type=\"custom\" icon_img=\"id^16758|url^https://www.heyusa.com/nl/wp-content/uploads/2023/07/heyusa-expert-tip.png|caption^Hey!USA Expert Tip over reizen naar Amerika|alt^Hey!USA Expert Tip over reizen naar Amerika|title^Hey!USA Expert Tip over reizen naar Amerika|description^Hey!USA Expert Tip over reizen naar Amerika\" content_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" content_font_size=\"desktop:25px;\" content_font_color=\"#282828\"]Hey!USA\r\npersoonlijke tips:[/ultimate_icon_list_item][/ultimate_icon_list][vc_column_text]\r\n<ul>\r\n \t<li>Hoe lang verblijven? <em>4</em><em>\u00a0volle dagen</em></li>\r\n \t<li>Auto nodig?\u00a0<em><a href=\"https://www.heyusa.com/nl/auto-huren-in-amerika/\">Huurauto</a> is noodzakelijk</em></li>\r\n \t<li>Beste periode? <em>Tussen april en mei en september en oktober</em></li>\r\n \t<li>Drukste maanden? <em>Juli, december en februari</em></li>\r\n \t<li>Warmste maand? <em>Augustus</em></li>\r\n \t<li>Meeste regen? <em>Juni, augustus en september</em></li>\r\n \t<li>Hotel aanbevelingen voor Palm Beach: <a href=\"https://www.booking.com/hotel/us/the-breakers-palm-beach.en.html?aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=palmbeachbreakers\" target=\"_blank\" rel=\"noopener\">The Breakers Palm Beach</a>| <a href=\"https://www.booking.com/hotel/us/hammon-ave.en.html?aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=palmbeachcolony\">The Colony Hotel</a></li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ontdek in Florida\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][fullwidth_row][thb_postgrid columns=\"4\" source=\"post_type:post|by_id:-16174,15355,-15163,-4725,-1559,16342,16400,16507\"][/vc_column][/vc_row]","post_title":"Palm Beach &#038; West Palm Beach in Florida","post_link":"https://www.heyusa.com/nl/palm-beach-florida/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"West palm Beach\" width=\"300\" height=\"225\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/07/west-palm-beach-1-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Stedentrips","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1689956280731{padding-top: 50px !important;padding-bottom: 50px !important;background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2021/08/all-day-usa-background.gif?id=8408) !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}.vc_custom_1689955486087{background-color: #ffffff !important;border-radius: 10px !important;}","%_edit_lock%":"1692101422:2","%_edit_last%":"2","%_wpb_vc_js_status%":"true","%post-primary-category%":"16","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Palm Beach Florida","%_yoast_wpseo_title%":"Palm Beach%%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een waar paradijs voor de kust van Florida, Palm Beach. Benieuwd wat je kunt doen in Palm Beach en omgeving?","%_yoast_wpseo_linkdex%":"78","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"Sanibel Island, Florida, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"26.4433972","%_wpgmp_metabox_longitude%":"-82.1115119","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"7","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1692101527","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_primary_category%":"62","%post_via%":[{"title":"Peanut Island \u00a9 Peter W. Cross","post_source_url":"visitflorida.com"},{"title":"West Palm Beach \u00a9 NPI Productions","post_source_url":"visitflorida.com"}],"%_thumbnail_id%":"16703","%standard-featured-credit%":"\u00a9 NPI Productions","taxonomy=category":"Stedentrips","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":16521,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Windley Key Fossil Reef Geological State Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Overblijfselen van oude machines om kalksteen te delven in Windley Key Fossil Reef Geological State Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/07/windley-key-fossil-reef-state-park-overblijfselen-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Windley Key Fossil Reef Geological State Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"84900 Overseas Hwy, Islamorada, FL 33036, Verenigde Staten","location":{"lat":"24.9571235","city":"Islamorada","state":"Florida","country":"Verenigde Staten","lng":"-80.59511479999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/windley-key-fossil-reef-geological-state-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row css=\".vc_custom_1689321593303{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Florida State Park\" font_size=\"55\" line_height=\"60\" font_color=\"#87a375\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][vc_custom_heading text=\"Windley Key Fossil Reef Geological State Park\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"De geschiedenis van Key Limestone (kalksteen)\" font_container=\"tag:h3|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:300%20light%20regular%3A300%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">De Florida Keys zijn ongeveer 130.000 jaar geleden ontstaan door een combinatie van geologische activiteit. De eilanden bestaan uit koraalriffen die miljoenen jaren geleden zijn gevormd en vervolgens bedekt werden door sedimenten. Door tektonische bewegingen en stijging van de zeespiegel ontstonden uiteindelijk de eilanden. Het resultaat is een unieke archipel van prachtige eilanden en koraalriffen. Jarenlang werd in de groeve van dit Windley Key Fossil Reef Geological State Park het beroemde 'Key Limestone' gedolven. Dit kalksteen is onder andere gebruikt voor de Florida East Coast Railroad en om verschillende gebouwen in Coral Gables in Miami te bouwen.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"95%\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"25px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Educatief State Park in Florida\" font_container=\"tag:h3|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"84900 Overseas Highway | Islamorada\"][vc_column_text]Dit Florida State Park wordt onterecht vaak overgeslagen door bezoekers die richting Key West rijden. Het moet dan ook opboksen tegen populaire parken als <a href=\"https://www.heyusa.com/nl/john-pennekamp-coral-reef-state-park/\" target=\"_blank\" rel=\"noopener\">John Pennekamp Coral Reef State Park</a> en <a href=\"https://www.heyusa.com/nl/bahia-honda-state-park/\" target=\"_blank\" rel=\"noopener\">Bahia Honda</a>. Waar je in deze parken vooral kunt genieten van de natuur, strand en snorkelen, heeft Windley Key Fossil Reef Geological State Park vooral een educatieve opzet naast verschillende mooie trails.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]<span class=\"LrzXr kno-fv\">2,50 per persoon</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-automobile car\"]131 kilometer van Miami[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">40 soorten bomen</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-bank institution university\"]<span class=\"LrzXr kno-fv\">Klein museum</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-location-arrow\"]<span class=\"LrzXr kno-fv\">2,4 kilometer trails</span>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"25px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1640066907439{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"375px\"][vc_custom_heading text=\"Kalksteengroeve voor Henry Flagler's spoorlijn\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Henry Flagler's Overseas Railroad\" font_size=\"60\" line_height=\"65\" font_color=\"#ffffff\"][vc_empty_space height=\"375px\"][parallax_row opacity=\"90\" enable_mobile=\"parallax-enable-mobile\" image=\"16629\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelingen &amp; trails\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]Het Windley Key Fossil Reef Geological State Park in <a href=\"https://www.heyusa.com/nl/islamorada-florida-keys/\" target=\"_blank\" rel=\"noopener\">Islamorada</a> staat vooral bekend om zijn geologische geschiedenis en is minder een park om te wandelen. De bijna 2,5 kilometer aan trails staan dan ook in het teken van z'n tijd als kalksteengroeve. Je passeert langs plekken waar kalksteen gedolven is. Je ziet oude apparatuur uit de vroege jaren 1900 en restanten van kalksteen. Het park ligt ook zo'n twee a drie meter diep, vanwege het uitgehakte kalksteen.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]Geopend vanaf 8.00 uur tot 17:00 uur. Gesloten op dinsdag en woensdag.[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Er zijn gratis ranger-tours om 10:00 uur 's morgens en om 14:00 uur[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-paw\" content_font_size=\"desktop:16px;\"]Vogels en kleine dieren spotten[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tint\" content_font_size=\"desktop:16px;\"]Gratis drinkwaterfontein[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1640066907439{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"375px\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Leer meer over de Florida Keys en z'n geschiedenis\" font_size=\"60\" line_height=\"65\" font_color=\"#ffffff\"][vc_custom_heading text=\"Klein museum van Windley Key Fossil Reef Geological State Park\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"375px\"][parallax_row opacity=\"90\" enable_mobile=\"parallax-enable-mobile\" image=\"16633\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" thb_row_padding=\"true\" thb_column_padding=\"true\" content_placement=\"middle\"][vc_column width=\"1/2\"][vc_row_inner][vc_column_inner width=\"5/6\"][heyusa_heading tag=\"div\" heading=\"Handig om te weten!\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][vc_custom_heading text=\"Hoe kom je bij Windley Key Fossil Reef Geological State Park?\" font_container=\"tag:h3|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Op de route van Miami naar Key West via de Overseas Highway kom je Windley Key Fossil Reef Geological State Park tegen aan je rechterkant. Het park ligt ongeveer 20 minuten rijden vanaf <a href=\"https://www.heyusa.com/nl/key-largo/\">Key Largo</a>. Dit Florida State Park heeft geen grote entree en je rijdt er gemakkelijk voorbij, goed opletten dus![/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][thb_image retina=\"retina_size\" full_width=\"true\" image=\"16635\"][/thb_image][/vc_column][/vc_row][vc_row thb_full_width=\"true\" thb_row_padding=\"true\" thb_column_padding=\"true\" content_placement=\"middle\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][thb_image retina=\"retina_size\" full_width=\"true\" image=\"16637\"][/thb_image][/vc_column][vc_column width=\"1/2\"][vc_row_inner][vc_column_inner width=\"5/6\"][heyusa_heading tag=\"div\" heading=\"Absoluut een tussenstop waard!\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][vc_custom_heading text=\"Wat te doen in het Windley Key Fossil Reef Geological State Park\" font_container=\"tag:h3|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het park is vooral bijzonder omdat je hier ontdekt dat de eilanden van de Florida Keys, onder de grond, bestaan uit kalksteen. Steen waar je fossielen in kunt vinden en zelfs de vormen van het koraal herkent. Op de grote vlakte liggen nog resten van kalkstenen blokken die onbruikbaar waren. Je ziet grote machines waarmee ze de blokken uithakten en loopt letterlijk over fossielen.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" thb_row_padding=\"true\" thb_column_padding=\"true\" content_placement=\"middle\"][vc_column width=\"1/2\"][vc_row_inner][vc_column_inner width=\"5/6\"][heyusa_heading tag=\"div\" heading=\"Hoe werkte zo'n groeve?\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][vc_custom_heading text=\"Duidelijke uitleg over de kalksteengroeve die tot de jaren '60 nog in werking was.\" font_container=\"tag:h3|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Overal in het park kom je oude machines tegen waarmee ze de blokken 'Key Largo Limestone' hakten en verplaatsten. Bij alle overgebleven machines wordt door middel van borden uitgelegd hoe ze werkten en waarvoor ze dienden. Je komt op deze manier veel te weten over de delving van het kalksteen.\r\n\r\nMeer weten? Check de <a href=\"https://www.floridastateparks.org/WindleyKey\" target=\"_blank\" rel=\"noopener\">offici\u00eble Florida State Park</a> pagina[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][thb_image retina=\"retina_size\" full_width=\"true\" image=\"16640\"][/thb_image][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"75px\"][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ontdek meer natuur in de buurt\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][ultimate_heading main_heading=\"Nog meer Florida\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:40px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:45px;\"][/ultimate_heading][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"25px\"][thb_postbackground style=\"style2\" source=\"by_id:-16192,-16204,16174,16126,-15644,-15614,-15580,-8105,-1262,-2267,-572,-545,16300\"][/vc_column][/vc_row]","post_title":"Windley Key Fossil Reef Geological State Park","post_link":"https://www.heyusa.com/nl/windley-key-fossil-reef-geological-state-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Overblijfselen van oude machines om kalksteen te delven in Windley Key Fossil Reef Geological State Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/07/windley-key-fossil-reef-state-park-overblijfselen-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"State Parks","post_tags":"Florida","%_last_editor_used_jetpack%":"classic-editor","%_edit_lock%":"1689329665:1","%_edit_last%":"1","%_thumbnail_id%":"16554","%_yoast_indexnow_last_ping%":"1689325455","%_hide_featured%":null,"%_wpgmp_location_address%":"84900 Overseas Hwy, Islamorada, FL 33036, Verenigde Staten","%_wpgmp_location_city%":"Islamorada","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"24.9571235","%_wpgmp_metabox_longitude%":"-80.59511479999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%inline_featured_image%":"0","%_yoast_wpseo_primary_category%":"170","%_yoast_wpseo_content_score%":"30","%_wpb_shortcodes_custom_css%":".vc_custom_1689321593303{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1640066907439{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1640066907439{padding-top: 25px !important;background-color: #000000 !important;}","%_yoast_wpseo_focuskw%":"Windley Key","%_yoast_wpseo_metadesc%":"Dit bijzondere Florida State Park wordt onterecht overgeslagen. Je komt hier meer te weten over Key Largo Limestone in de oude kalksteengroeve.","%_yoast_wpseo_linkdex%":"75","taxonomy=category":"State Parks","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/park-icon.png"},"id":16553,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/park-icon.png","name":"Parken","id":"3","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Bill Baggs Cape Florida State Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Bill Baggs Cape Florida State Park\" width=\"300\" height=\"169\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/06/Bill-Baggs-Cape-Florida-State-Park-aerial-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Bill Baggs Cape Florida State Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1200 Crandon Blvd, Key Biscayne, FL 33149, Verenigde Staten","location":{"lat":"25.6755217","city":"Key Biscayne","state":"Florida","country":"Verenigde Staten","lng":"-80.1590677","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/bill-baggs-cape-florida-state-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Bill Baggs Cape Florida State Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Op het eiland Key Biscayne vind je het Bill Baggs Cape Florida State Park. Vanaf Downtown Miami makkelijk te bereiken met de brug. Het staatspark neemt ongeveer een derde van het eiland in beslag. De stranden van het Bill Baggs Cape Florida State Park staan vaak in het lijstje met de <a href=\"https://www.heyusa.com/nl/mooiste-stranden-amerika/\">mooiste stranden van Amerika</a>. Een goede reden om eens een bezoek te nemen aan het staatspark voor de kust van Miami.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]14 kilometer van Miami[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">160 hectare</span>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Ontstaan van het Bill Baggs Cape Florida State Park\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Cape Florida, zoals het gebied van oorsprong heet, wordt voor het eerst genoemd in 1513 toen een Spaanse expeditie op de plek aankwam. Lange tijd woonden er Seminole indianen op het eiland. In de 19e eeuw werd het Bill Baggs Cape Florida State Park een plek voor Black Seminole indianen die hiervandaan ontsnapten naar de Bahama's. Sinds 2004 staat er een marker die herinnert aan deze periode. Het gebied op Key Biscayne heette lange tijd Cape Florida, pas later werd het vernoemd naar Bill Baggs, redacteur van Miami News. Bill Baggs zette zich in voor het behoud van de natuur in dit gebied.[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Bill Baggs Cape Florida State Park\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Een van de mooiste stranden van Amerika\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"16305\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Hoe kom je bij het Bill Baggs Cape Florida State Park?\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Bill Baggs Cape Florida State Park ligt voor de kust van <a href=\"https://www.heyusa.com/nl/miami/\">Miami</a> op het eiland Key Biscayne. Het is vanaf Downtown Miami makkelijk te bereiken met de auto. In slechts twintig minuten ben je al in het park. In de weekenden kan het er druk zijn en wordt er met het vol is vol principe gewerkt.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten in Bill Baggs Cape Florida State Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Je kunt helaas niet overnachten in het Bill Baggs Cape Florida State Park. Alleen met de boot kun je aanmeren in de No Name Harbor. Voor ongeveer 20 euro per nacht, per boot kun je hier een nachtje doorbrengen. Wil je overnachten in een hotel? Dan raden we\u00a0<a href=\"https://www.booking.com/searchresults.en.html?city=20022827&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=billbaggsstateparkkeybiscayne\" target=\"_blank\" rel=\"noopener\">Key Biscayne</a> aan. Overigens kun je het Bill Baggs Cape Florida State Park ook prima als dagtrip bezoeken vanuit Miami.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Wat te doen in het Bill Baggs Cape Florida State Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het strand van het Bill Baggs Cape Florida State Park is een van de voornaamste redenen om het park te bezoeken. Niets voor niets haalt deze al jaren lijstjes met de mooiste stranden van Amerika.\u00a0 Zowel aan de Atlantische Oceaan als Biscayne Bay vond je een prachtige kustlijn. Je kunt op het eiland fietsen en wandelen, maar verwacht geen lange paden. Al wandelend kun je wel een kijkje nemen bij de Mangrove Wetlands of langs de kust wandelen. Zwemmen en snorkelen kan op verschillende plekken, net als vissen, kano\u00ebn en kajakken. Op het eiland vind je nog een vuurtoren die de moeite waard is om te bezoeken. Het is het oudste gebouw van Zuid Florida en staat al sinds 1825 op Cape Florida.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reisperiode om het Bill Baggs Cape Florida State Park te bezoeken\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Florida is een staat die je het hele jaar kunt bezoeken, zo ook het Bill Baggs Cape Florida State Park. Wil je het park bezoeken met de minste kans op regen? Dan zijn de maanden januari, februari en maart de beste periode om het park te bezoeken.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Wandelen in het park\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Perfecte manier om te ontdekken\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"16304\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelingen &amp; trails\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]De belangrijkste reden om het Bill Baggs Cape Florida State Park te bezoeken zijn de stranden. Wandelen is mogelijk in het park, maar verwacht geen enorm lange wandelpaden. In het westen van het park liggen nature trails en in het noorden vind je een trail naar de mangrove wetlands.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]365 dagen per jaar - vanaf 8.00 uur tot zonsondergang[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]Toegang met een auto $6 - 2 tot 8 personen\r\nToegang voor voetgangers $2[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: hele jaar - minste regen in januari, februari en maart[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"75px\"][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ontdek meer natuur in de buurt\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][ultimate_heading main_heading=\"Nog meer Florida\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:40px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:45px;\"][/ultimate_heading][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"25px\"][thb_postbackground style=\"style2\" source=\"by_id:-15644,-15614,-15580,-8105,-1262,-2267,-572,-545,16204,16174,16192,16126\"][/vc_column][/vc_row]","post_title":"Bill Baggs Cape Florida State Park","post_link":"https://www.heyusa.com/nl/bill-baggs-cape-florida-state-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Bill Baggs Cape Florida State Park\" width=\"300\" height=\"169\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/06/Bill-Baggs-Cape-Florida-State-Park-aerial-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"State Parks","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}","%inline_featured_image%":"0","%_edit_lock%":"1689324811:1","%_edit_last%":"2","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Bill Baggs Cape Florida State Park\"]","%_yoast_wpseo_focuskw%":"Bill Baggs Cape Florida State Park","%_yoast_wpseo_metadesc%":"Ontdek Bill Baggs Cape Florida State Park in de staat Florida. Benieuwd wat je er kunt doen? Tips voor Bill Baggs Cape Florida State Park.","%_yoast_wpseo_linkdex%":"48","%_wpgmp_location_address%":"1200 Crandon Blvd, Key Biscayne, FL 33149, Verenigde Staten","%_wpgmp_location_city%":"Key Biscayne","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.6755217","%_wpgmp_metabox_longitude%":"-80.1590677","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_primary_category%":"170","%_yoast_wpseo_title%":"Bill Baggs Cape Florida State Park %%page%% %%sep%% %%sitename%%","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1687858123","%_last_editor_used_jetpack%":"classic-editor","%standard-featured-credit%":"","%_thumbnail_id%":"16303","taxonomy=category":"State Parks","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png"},"id":16300,"infowindow_disable":false},{"source":"post","title":"Oleta River State Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Uitzicht Oleta river State Park\" width=\"300\" height=\"169\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/06/oleta-river-park-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Oleta River State Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"3400 NE 163rd St, North Miami Beach, FL 33160, Verenigde Staten","location":{"lat":"25.9279547","city":"North Miami Beach","state":"Florida","country":"Verenigde Staten","lng":"-80.1359543","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/oleta-river-state-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Oleta River State Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Oleta River State Park is een staatspark in Florida net ten noorden van Miami. De naam komt van de Oleta Rivier die er doorheen stroomt. In het park vind je een grote concentratie Casuarina bomen, ook wel de Australian Pine. Hoewel de rivier een grote publiekstrekker is voor zowel locals als toeristen, is er meer te doen in het Oleta River State Park. Op slechts 30 minuten van Miami kun je in het grootste stadspark van Florida genieten van prachtige natuur, activiteiten of gewoon heerlijk relaxen.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]30 kilometer van Miami[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">4,2 km2</span>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Ontstaan van het Oleta River State Park\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De rivier Oleta is de belangrijkste ader van het gebied. Hiervoor kwamen mensen al sinds 500 voor Christus naar de regio. Destijds werden de oevers van de rivier gebruikt als kampeerterrein voor de Tequesta indianen. Later werd het gebied een tijde bezet door Amerikaanse troepen tijdens de Tweede Seminole oorlog (1841). Sinds eind 1800 werd het gebied steeds meer en meer bevolkt en in 1922 werd de naam Big Snake Creek veranderd naar Oleta Rivier. Vroeger stroomde de rivier nog naar de <a href=\"https://www.heyusa.com/nl/everglades-national-park/\">Everglades</a>, inmiddels niet meer.[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Oleta river State Park\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Perfecte plek om te kajakken, suppen of kano\u00ebn\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"16280\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Hoe kom je bij het Oleta River State Park?\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Oleta River State Park ligt ten noorden van Miami, in de buurt van <a href=\"https://www.heyusa.com/nl/miami-north-beach/\">North Miami</a>. In slechts 30 minuten sta je in het park, een compleet andere wereld met mangrovebossen en het schilderachtige Biscayne Bay, kortom een natuurlijke oase.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten in Oleta River State Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Je kunt overnachten in het Oleta River State Park, zei het op een primitieve manier. Er bevinden zich cabins en kampeerplekken voor jeugd in het park. Er zijn geen kook- of douchegelegenheden, maar de cabins zijn wel uitgerust met airco. Wil je overnachten in een hotel? Dan raden we <a href=\"https://www.booking.com/searchresults.en.html?city=20023366&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=oletarivernorthmiami\" target=\"_blank\" rel=\"noopener\">North Miami</a> aan of <a href=\"https://www.booking.com/searchresults.en.html?city=20023182&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=oletarivermiamibeach\" target=\"_blank\" rel=\"noopener\">Miami Beach</a>. Daar zijn genoeg hotels en van daaruit kun je het park bezoeken.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Wat te doen in het Oleta River State Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De belangrijkste reden om Oleta River State Park te bezoeken is het prachtige kano gebied. De rivier is omringd door mangrove bossen waardoor het een ervaring op zich is om doorheen te peddelen. Natuurlijk kun je hier ook kajakken of Suppen. Zwemmen kan overigens alleen in het zoutwater gedeelte van Biscayne Bay. Een andere activiteit die je in het Oleta River State Park kunt doen is fietsen. Er is ongeveer 20-25 kilometer aan off-road paden voor mountainbikers. Voor beginners zijn er makkelijkere trails. De geasfalteerde paden zijn eventueel ook geschikt voor skaters. Daarnaast is het park een perfecte plek om wildlife zoals reigers, lepelaars, dolfijnen of <a href=\"https://www.heyusa.com/nl/manatees-florida/\">manatees</a> te zien.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reisperiode om het Oleta River State Park te bezoeken\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Florida is een staat die je het hele jaar kunt bezoeken, zo ook het Oleta River State Park. Wil je het park bezoeken met de minste kans op regen? Dan zijn de maanden januari, februari en maart de beste periode om het park te bezoeken.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Oleta River State Park\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Perfecte escape vanuit Miami\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"16292\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelingen &amp; trails\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]De belangrijkste reden om het Oleta River State Park te bezoeken zijn de wateractiviteiten. Wandelen is mogelijk, maar er is slechts \u00e9\u00e9n wandelpad van ongeveer 5 kilometer. Voor mountainbiken zijn er meer mogelijkheden. Je hebt ongeveer 16 kilometer aan 'intermediate' mountainbike tracks. Voor beginners is er een pad van 6,5 kilometer en 5 kilometer.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]365 dagen per jaar - vanaf 8.00 uur tot zonsondergang[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]Toegang met een auto $6 - 2 tot 8 personen\r\nToegang voor voetgangers $2[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: hele jaar - minste regen in januari, februari en maart[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"75px\"][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ontdek meer natuur in de buurt\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][ultimate_heading main_heading=\"Nog meer Florida\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:40px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:45px;\"][/ultimate_heading][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"25px\"][thb_postbackground style=\"style2\" source=\"by_id:-15644,-15614,-15580,-8105,-1262,-2267,-572,-545,16204,16174,16192,16126\"][/vc_column][/vc_row]","post_title":"Oleta River State Park","post_link":"https://www.heyusa.com/nl/oleta-river-state-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Uitzicht Oleta river State Park\" width=\"300\" height=\"169\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/06/oleta-river-park-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"State Parks","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}","%inline_featured_image%":"0","%_edit_lock%":"1687858056:2","%_edit_last%":"2","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Oleta River State Park","%_yoast_wpseo_metadesc%":"Ontdek Oleta River State Park in de staat Florida. Benieuwd wat je er kunt doen? Tips voor je bezoek aan Oleta River State Park.","%_yoast_wpseo_linkdex%":"82","%_wpgmp_location_address%":"3400 NE 163rd St, North Miami Beach, FL 33160, Verenigde Staten","%_wpgmp_location_city%":"North Miami Beach","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.9279547","%_wpgmp_metabox_longitude%":"-80.1359543","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_primary_category%":"170","%_yoast_wpseo_title%":"Oleta River State Park %%page%% %%sep%% %%sitename%%","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1687857937","%_last_editor_used_jetpack%":"classic-editor","%standard-featured-credit%":"","%_thumbnail_id%":"16281","taxonomy=category":"State Parks","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png"},"id":16278,"infowindow_disable":false},{"source":"post","title":"Hamburgers &#038; vliegtuigspotten: In-N-Out in Los Angeles","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hamburgers eten bij In-N-Out Burger en vliegtuigen spotten nabij LAX in Los Angeles\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/06/In-N-Out-Burger-bij-LAX-airport-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Hamburgers &#038; vliegtuigspotten: In-N-Out in Los Angeles</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"9149 S Sepulveda Blvd, Los Angeles, CA 90045, Verenigde Staten","location":{"lat":"33.9537741","city":"Los Angeles","state":"California","country":"Verenigde Staten","lng":"-118.3967088","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/vliegtuigspotten-in-n-out-in-los-angeles/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Over In-N-Out Burger\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<strong>Het is \u00e9\u00e9n van de meest geliefde fastfoodketens van Amerika: In-N-Out Burger, bekend vanwege zijn 'secret menu', vriendelijk personeel en volgens velen d\u00e9 lekkerste fastfood-burgers. De keten werd in 1948 opgericht in Baldwin Park, Californi\u00eb, door Harry en Esther Snyder en heeft inmiddels meer dan 380 filialen.</strong>\r\n\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Iconische In-N-Out Burger locatie in Los Angeles\" font_container=\"tag:h2|font_size:45|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Een iconisch filiaal van In-N-Out Burger vind je nabij de internationale luchthaven van <a href=\"https://www.heyusa.com/nl/los-angeles/\" target=\"_blank\" rel=\"noopener\">Los Angeles</a>: LAX. Terwijl je smult van je 'Double-Double' met de beroemde 'In-N-Out spread', kun je vliegtuigen spotten die de luchthaven van Los Angeles naderen. Onze beste tip is dan ook: <em>Ga buiten zitten</em>. De vliegtuigen passeren op ongeveer 50 meter hoogte voorbij, waardoor het bijna lijkt alsof je ze kunt aanraken.</p>\r\n[/vc_column_text][vc_empty_space height=\"75px\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"95%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1687603583589{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Vergeet niet te zwaaien!\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Passerende vliegtuigen voorbij In-N-Out Burger\" font_size=\"45\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"90\" enable_mobile=\"parallax-enable-mobile\" image=\"16252\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"95%\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_column_text]\r\n<h3>Grootste passagiersvliegtuig ter wereld</h3>\r\nAangezien LAX \u00e9\u00e9n van de drukste luchthavens ter wereld is met weinig beschikbare slots (landingsrechten), wordt door meerdere maatschappijen de A380 ingezet, het grootste passagierstoestel ter wereld. Onder andere Emirates, Singapore Airlines en Qantas vliegen met deze reus naar Los Angeles.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_column_text]\r\n<h3>Klein park v\u00f3\u00f3r In-N-Out Burger in LA</h3>\r\nWil je de vliegtuigen letterlijk over je heen zien vliegen? Ga dan naar het kleine driehoekig parkje dat voor <a href=\"https://www.in-n-out.com\" target=\"_blank\" rel=\"noopener\">In-N-Out Burger</a> ligt. Je bent overigens niet de enige, want dit is d\u00e9 plek om vliegtuigen te spotten. Ze vliegen namelijk letterlijk over je heen![/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_column_text]\r\n<h3>Waar ligt deze hotspot in Los Angeles?</h3>\r\nZet het volgende adres in je navigatie: 9149 S Sepulveda Blvd, Los Angeles, CA 90045[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Vliegtuigspotten nabij LAX bij In-N-Out Burger\" font_container=\"tag:h3|font_size:45|text_align:center|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"De indrukwekkende A380 vliegt voorbij\" font_container=\"tag:h3|font_size:45|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"25px\"][thb_image_slider lightbox=\"mfp-gallery\" images=\"16250,16251,16252\"][fullwidth_row content_width=\"95%\"][/vc_column][/vc_row]","post_title":"Hamburgers &#038; vliegtuigspotten: In-N-Out in Los Angeles","post_link":"https://www.heyusa.com/nl/vliegtuigspotten-in-n-out-in-los-angeles/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hamburgers eten bij In-N-Out Burger en vliegtuigen spotten nabij LAX in Los Angeles\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/06/In-N-Out-Burger-bij-LAX-airport-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Eten en drinken","post_tags":"Californi\u00eb","%_last_editor_used_jetpack%":"classic-editor","%_edit_lock%":"1687632400:1","%_edit_last%":"1","%_thumbnail_id%":"16248","%_yoast_indexnow_last_ping%":"1687632397","%_hide_featured%":null,"%_wpgmp_location_address%":"9149 S Sepulveda Blvd, Los Angeles, CA 90045, Verenigde Staten","%_wpgmp_location_city%":"Los Angeles","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"33.9537741","%_wpgmp_metabox_longitude%":"-118.3967088","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"15\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%inline_featured_image%":"0","%_yoast_wpseo_primary_category%":"66","%_yoast_wpseo_focuskw%":"In-N-Out Burger LAX","%_yoast_wpseo_metadesc%":"Smullen van bamburgers bij In-N-Out Burger \u00e9n vliegtuigspotten bij LAX in Los Angeles. De toestellen vliegen op 50m hoogte voorbij!","%_yoast_wpseo_linkdex%":"72","%_wpb_shortcodes_custom_css%":".vc_custom_1687603583589{padding-top: 25px !important;background-color: #000000 !important;}","taxonomy=category":"Eten en drinken","taxonomy=post_tag":"Californi\u00eb","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/food.png"},"id":16247,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/food.png","name":"Food","id":"15","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Florida Caverns State Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Grotten Florida Caverns\" width=\"300\" height=\"169\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/06/florida-caverns-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Florida Caverns State Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"3345 Caverns Rd, Marianna, FL 32446, Verenigde Staten","location":{"lat":"30.8150095","city":"Marianna","state":"Florida","country":"Verenigde Staten","lng":"-85.23185819999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/florida-caverns-state-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Florida Caverns State Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Florida Caverns State Park is een staatspark in Florida dat bekend is geworden vanwege de grotten in het gebied. Het is namelijk de enige staatspark in Florida met grotten die toegankelijk zijn voor het publiek. De kalksteengrotten zijn een publiekstrekker in de staat. Je kunt er stalagmieten, stalactieten en stroomstenen zien die gevormd zijn door erosie. Naast de grotten biedt het staatspark nog meer mogelijkheden tot activiteiten. Benieuwd welke dat zijn? Lees meer over het Florida Caverns State Park.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]100 kilometer van Tallahassee[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">586 hectare</span>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Ontstaan van Florida Caverns State Park\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De geschiedenis van de grotten in het Florida Caverns State Park gaat zo'n 38 miljoen jaar terug. De zeespiegel was destijds een stuk hoger en de kustvlaktes in Florida kwamen onder water te staan. Schelpen, koraal en sedimenten hoopten zich op op de zeebodem. Met het dalen van zeespiegel verhardde dit tot kalksteen. In de jaren erna loste zuur grondwater spleten onder het oppervlak waardoor er doorgangen in de grotten kwamen. Hierdoor ontstonden er stalactieten, stalagmieten en andere grotformaties. Een perfecte plek voor blinde grotkreeften, grotsalamanders en vleermuizen.[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Florida Caverns State Park\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Meer dan alleen grotten\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"16202\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Hoe kom je bij het Florida Caverns State Park?\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Florida Caverns State Park ligt in het noordwesten van Florida. De bekendste stad in de buurt is Tallahassee dat op ruim 100 kilometer rijden ligt. Een iets kleinere stad is Marianna, dat op slechts 5 kilometer ligt.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten in Florida Caverns State Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In het Florida Caverns State Park is er plek om te kamperen in een tent of camper. Er zijn 38 plekken beschikbaar. Wil je overnachten in een hotel? Dan kan in <a href=\"https://www.booking.com/searchresults.en.html?city=20023114&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=floridacavernsstateparkmariana\" target=\"_blank\" rel=\"noopener\">Marianna</a> dat op 5 kilometer van het park ligt.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Wat te doen in het Florida Caverns State Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De belangrijkste trekpleister in het Florida Caverns State Park zijn natuurlijk de grotten. Deze zijn alleen te bezoeken met een tour. In het hoogseizoen worden deze 7 dagen per week gegeven, ze duren ongeveer 45 minuten. Je kunt tickets kopen in het park en het werkt op basis van first come, first served. Andere activiteiten die je kunt ondernemen in het Florida Caverns State Park zijn fietsen, wandelen, paardrijden, kano\u00ebn en zwemmen. Voor het wandelen, fietsen en paardrijden zijn verschillende routes uitgezet om te volgen. En niet te vergeten, voor de liefhebber is er een 9 hole golfbaan.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reisperiode om het Florida Caverns State Park te bezoeken\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Florida is een staat die je het hele jaar kunt bezoeken, zo ook de grotten in het Florida Caverns State Park. In het hoogseizoen worden er alle dagen tours gegeven door de grotten, hierdoor ben je iets minder afhankelijk van de tijden van de tours.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelingen &amp; trails\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]De belangrijkste reden om het Florida Caverns State Park te bezoeken zijn natuurlijk de grotten. Toch zijn er een drietal trails die je kunt lopen in het park:\r\n<ul>\r\n \t<li>Bluff and Beech Magnolia Trail</li>\r\n \t<li>Sinkhole Trail</li>\r\n \t<li>Bumpnose Trail</li>\r\n</ul>\r\nDe trails in het Florida Caverns State Park zijn overigens multi-use, dus kunnen ook gebruikt worden voor fietsen en paardrijden[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]365 dagen per jaar - vanaf 8.00 uur tot zonsondergang[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]Toegang met een auto $5 - 2 tot 8 personen\r\nToegang voor voetgangers $2[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: hele jaar[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"75px\"][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ontdek meer natuur in de buurt\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][ultimate_heading main_heading=\"Nog meer Florida\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:40px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:45px;\" margin_design_tab_text=\"\"][/ultimate_heading][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"25px\"][thb_postbackground style=\"style2\" source=\"by_id:-15644,-15614,-15580,-8105,-1262,-2267,-572,-545,16126,16204,16278,16174\"][/vc_column][/vc_row]","post_title":"Florida Caverns State Park","post_link":"https://www.heyusa.com/nl/florida-caverns-state-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Grotten Florida Caverns\" width=\"300\" height=\"169\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/06/florida-caverns-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"State Parks","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}","%inline_featured_image%":"0","%_edit_lock%":"1688730561:2","%_edit_last%":"2","%_thumbnail_id%":"16216","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Florida Caverns\"]","%_yoast_wpseo_focuskw%":"Florida Caverns State Park","%_yoast_wpseo_metadesc%":"Ontdek Florida Caverns State Park in de staat Florida. Benieuwd wat je er kunt doen? Tips voor je bezoek aan de grotten in Florida.","%_yoast_wpseo_linkdex%":"46","%_wpgmp_location_address%":"3345 Caverns Rd, Marianna, FL 32446, Verenigde Staten","%_wpgmp_location_city%":"Marianna","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"30.8150095","%_wpgmp_metabox_longitude%":"-85.23185819999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_primary_category%":"170","%_yoast_wpseo_title%":"Florida Caverns State Park %%page%% %%sep%% %%sitename%%","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1687773337","%_last_editor_used_jetpack%":"classic-editor","%standard-featured-credit%":" \u00a9 Dorothy Thames","taxonomy=category":"State Parks","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png"},"id":16192,"infowindow_disable":false},{"source":"post","title":"Sanibel Island","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sanibel Island\" width=\"300\" height=\"169\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/06/vuurtoren-sanibel-island-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Sanibel Island</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Sanibel Island, Florida, Verenigde Staten","location":{"lat":"26.4433972","state":"Florida","country":"Verenigde Staten","lng":"-82.1115119","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/sanibel-island/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"25px\"][vc_empty_space height=\"25px\"][ultimate_heading main_heading=\"Sanibel Island\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]<strong>Sanibel Island in Florida, bekend vanwege de prachtige witte stranden die ook nog eens vol liggen met de meest mooie schelpen. Tel daar nog eens palmbomen en een knalblauwe zee bij op en je hebt een waar paradijs om te bezoeken. De natuur is nog ongerept en je vindt er tal van prachtige vogels. Benieuwd wat je niet mag missen op Sanibel Island?\r\n</strong>[/vc_column_text][vc_empty_space height=\"25px\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Tropisch eiland in Florida\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Parelwitte stranden, helderblauwe zee, prachtige schelpen, ongerepte natuur en veel wildlife, dat moet wel een paradijs zijn. Dit paradijs wordt ook wel Sanibel Island genoemd en ligt voor de kust van Fort Myers. Je kunt er wandelen, fietsen, kajakken, kano\u00ebn of gewoon relaxen op het strand. Aan Sanibel Island ligt nog een klein eiland die je per brug kunt bereiken; Captiva Island. Het eiland is amper 6,5 kilometer lang en maximaal 1 kilometer breed. Ook hier vind je prachtige stranden, het grootste deel van het eiland is bestemd voor de natuur.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Wandel over het strand op Sanibel Island\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"En ontdek de mooiste schelpen\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"16208\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen op Sanibel Island\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/4\"][ultimate_heading main_heading=\"J.N. Ding Darling National Wildlife Refuge\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Het J.N. Ding Darling National Wildlife Refuge ligt aan de noordkust van Sanibel Island. Het reservaat staat bekend om de grote en diverse vogelpopulatie. Zo kun je er onder andere roze lepelaars en ibissen zien. Er zwemmen ook dolfijnen en manatees in de wateren van het J.N. Ding Darling National Wildlife Refuge. Je kunt het reservaat ontdekken per auto, fiets, kano of kajak. Voor het huren van\u00a0 kano's en kajaks moet je in Tarpon Bay zijn.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][ultimate_heading main_heading=\"Sanibel Lighthouse\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Sinds 1884 staat staat er een 30 meter hoge vuurtoren op Sanibel Island. De toren is nog in gebruik waardoor het helaas niet mogelijk is om hem te bezichtigen. Toch kun je de vuurtoren meenemen tijdens je bezoek aan Sanibel Island. Je vindt hem namelijk op het meest oostelijke puntje van het eiland en op de stranden rondom kun je goed naar schelpen zoeken.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][ultimate_heading main_heading=\"Stranden van Sanibel Island\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">De belangrijkste trekpleister van Sanibel Island zijn de stranden. Niet alleen vanwege het zand, het is vooral de plek om prachtige schelpen te vinden. Door de ligging van het eiland komen er met de Golfstroom prachtige schelpen mee naar Sanibel. Het is een van de mooiste plekken ter wereld om schelpen te vinden. Er zijn 5 verschillende strandopgangen, maar Bowmans is verreweg het populairst. Hier vind je geen bebouwing langs het strand. Wandel over het strand, zie pelikanen lopen, ontdek dolfijnen in de oceaan en vind de mooiste schelpen. Deze mag je overigens niet meenemen!</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][ultimate_heading main_heading=\"Old Town Sanibel\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Op het oostelijke deel van het eiland vind je het oude stadsdeel, ook wel Old Town genoemd. Het werd gevormd in 1974 door de aanleg van de hoofdweg die de veerboot verving. De enige gebouwen die op het eiland staan, zijn in die periode gebouwd. Door middel van een wandelroute van 4 kilometer kom je langs alle historische bezienswaardigheden in Old Town.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Paradijs in Florida\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"De stranden van Sanibel Island\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"16207\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ontdek in Florida\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_empty_space height=\"50px\"][fullwidth_row][thb_postgrid columns=\"4\" source=\"post_type:post|by_id:16174,15355,15163,4725,-1559\"][/vc_column][/vc_row]","post_title":"Sanibel Island","post_link":"https://www.heyusa.com/nl/sanibel-island/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sanibel Island\" width=\"300\" height=\"169\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/06/vuurtoren-sanibel-island-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Natuurgebieden","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1689078971:2","%_edit_last%":"2","%_wpb_vc_js_status%":"true","%post-primary-category%":"16","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Sanibel Island","%_yoast_wpseo_title%":"Sanibel Island%%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een waar paradijs voor de kust van Florida, Sanibel Island. Benieuwd wat je kunt doen op Sanibel Island? Lees dan onze tips voor Sanibel","%_yoast_wpseo_linkdex%":"75","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"Sanibel Island, Florida, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"26.4433972","%_wpgmp_metabox_longitude%":"-82.1115119","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"16209","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1689079100","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_primary_category%":"227","taxonomy=category":"Natuurgebieden","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":16204,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Lake Placid","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lake Placid\" width=\"300\" height=\"223\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/04/lake-placid-1-300x223.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Lake Placid</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Lake Placid, New York 12946, Verenigde Staten","location":{"lat":"44.2794911","city":"North Elba","state":"New York","country":"Verenigde Staten","lng":"-73.9798713","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/lake-placid/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Lake Placid\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Lake Placid is een rustig dorpje in de staat New York. Het ligt midden in het Adirondacks natuurgebied. Misschien bij sommigen bekend van de Olympische Winterspelen van 1932 en 1980. Het dorpje is gelegen aan het gelijknamige meer dat zowel in de zomermaanden als in de wintermaanden genoeg activiteiten biedt! Lake Placid is een van de 3000 meren die in het gebied liggen en in combinatie met het dorp het bezoeken waard.[/vc_column_text][vc_custom_heading text=\"Hey!USA Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Boek je hotel in de buurt van Lake Placid. Zo kun je en het meer en de omgeving verkennen!\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:100%20light%20regular%3A100%3Anormal\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612950540814{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Lake Placid\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">In de <a href=\"https://www.heyusa.com/nl/adirondacks/\">Adirondacks</a> vind je Lake Placid, een meer gelegen aan het gelijknamige dorpje. Het meer heeft een diepte van ongeveer 15 meter en is 8.8 km2 groot. Op het meer vind je 3 eilandjes met de naam Buck, Moose en Hawk. Leuk om te weten is dat het meer de inwoners voorziet van drinkwater. Vanuit de bergen stroomt het water het meer in. Rondom het meer staan ongeveer 300 woningen, maar die zijn de helft van de tijd leeg waardoor het water meestal schoon blijft.</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Lake Placid\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Het hele jaar door een bestemming om te bezoeken\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"15609\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"15617\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Lake Placid en de Olympische Spelen\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Zowel in 1932 als 1980 vonden de Olympische Winterspelen plaats in Lake Placid. Een unieke gebeurtenis voor dit relatief kleine stadje. In het Lake Placid Olympic Museum lees je alles over deze gebeurtenissen en kun je een uitgebreide collectie van de spelen terug zien. Bekijk fakkels, medailles en andere voorwerpen van de OS. Natuurlijk hoor je ook meer over de bizarre wedstrijd van de ijshockeyers die het machtige Rusland wisten te verslaan in 1980.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"15619\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Lake Placid in de zomer\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het fijne aan Lake Placid is dat het in alle jaargetijden goed te bezoeken is. In de zomermaanden kun je er mountainbiken, fietsen, wandelen en vissen. Je kunt er bijvoorbeeld de 200 kilometer lange Northville-Placid-Trail lopen. Minder zin om veel kilometers te maken maar toch een uitzicht mee te pakken? Neem dan de gondel naar de Whiteface berg. Verder kun je ook golfen rondom Lake Placid, de baan was de eerste in Amerika in 1898. En niet te vergeten zijn er op het water verschillende activiteiten om te ondernemen.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"15618\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Lake Placid in de winter\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Met twee keer de organisatie van de Olympische Spelen op zich, moet je je hier ook in de winter kunnen vermaken. Lake Placid is een van de plekken waar je kun snowboarden en <a href=\"https://www.heyusa.com/nl/skien-in-amerika/\">ski\u00ebn in Amerika</a>. Op het meer kun je met vorst schaatsen en ook ijsklimmen is een populaire activiteit in de winter. Daarnaast zijn er in het gebied een aantal langlauf tracks.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][thb_postbackground source=\"size:1|post_type:post|by_id:-1619,-667,14830\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"75px\"][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ontdek meer natuur in de buurt\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][ultimate_heading main_heading=\"Nog meer New York staat\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:40px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:45px;\"][/ultimate_heading][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"25px\"][thb_postbackground style=\"style2\" source=\"by_id:15580,8105,-1262,-2267,-572,-545,15644,15627\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row]","post_title":"Lake Placid","post_link":"https://www.heyusa.com/nl/lake-placid/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lake Placid\" width=\"300\" height=\"223\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/04/lake-placid-1-300x223.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Natuurgebieden","post_tags":"New York","%_wpb_shortcodes_custom_css%":".vc_custom_1612950540814{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%inline_featured_image%":"0","%_edit_last%":"2","%_edit_lock%":"1681302202:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"32","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"15620","%_yoast_wpseo_focuskw%":"Lake Placid","%_yoast_wpseo_metadesc%":"Een van de meren in de Adirondacks is Lake Placid. Benieuwd wat je bij Lake Placid en het gelijknamige dorpje kunt doen?","%_yoast_wpseo_linkdex%":"73","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Horseshoe bend \"]","%_wpgmp_location_address%":"Lake Placid, New York 12946, Verenigde Staten","%_wpgmp_location_city%":"North Elba","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"44.2794911","%_wpgmp_metabox_longitude%":"-73.9798713","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_primary_category%":"227","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1681302318","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Natuurgebieden","taxonomy=post_tag":"New York","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/parken.png"},"id":15614,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/parken.png","name":"Nationale Parken","id":"7","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Volcanoes National Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"volcanoes national park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/02/volcanoes-national-park-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Volcanoes National Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Hawaii Volcanoes National Park, HI 96785, Verenigde Staten","location":{"lat":"19.4290543","city":"Hawaii Volcanoes National Park","state":"Hawaii","country":"Verenigde Staten","lng":"-155.2568892","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/volcanoes-national-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Volcanoes National Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De eilanden van Hawaii bestaan uit prachtige natuur. E\u00e9n van de nationale parken van <a href=\"https://www.heyusa.com/nl/hawaii/\">Hawaii</a> is Volcanoes National Park op het eiland Hawaii. Een park dat redelijk uniek is. Het herbergt twee van de meest bijzondere vulkanen ter wereld: Kilauea en Mauna Loa. De eerste is de meest actieve vulkaan ter wereld en Mauna Loa de grootste. Een goede reden om een bezoek te brengen aan Volcanoes National Park.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">1347,9 km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Volcanoes National Park gevaarlijk?\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Bij een park met 2 actieve vulkanen denk je vast aan de veiligheid. Want hoe gevaarlijk is het Volcanoes National Park en hoe groot is de kans op een uitbarsting? Zo vonden er in mei 2018 explosies plaats in het Kilauea gebied. Hierbij kwamen giftige aswolken vrij en vonden er kleine aardbevingen plaats. Delen van het park werden gesloten en pas in september 2018 weer geopend. Vanaf 2022 is het grootste deel weer open. De Kilauea vulkaan is vanaf 2008 weer actief en wordt in de gaten gehouden. De kans blijft aanwezig dat je op Hawaii bent en je bezoek moet uitstellen vanwege vulkanische activiteiten.</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Crater Rim Drive\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Schade van een aardbeving\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"15072\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Facts Volcanoes National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Volcanoes National Park is een uniek park in Amerika. De vulkanische landschappen hebben een uniek eco systeem met bijzondere flora en fauna. Het gebied is sinds 1916 een nationaal park dat bijna het gehele eiland Hawaii beslaat. Sinds 1987 behoort Volcanoes National Park tot UNESCO Werelderfgoed.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Beste reisperiode Volcanoes National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De beste periode om Volcanoes National Park te bezoeken is eigenlijk het hele jaar door. De temperaturen verschillende gedurende het jaar niet veel op Hawaii. In februari, maart, oktober, november en december heb je de meeste kans op regen.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Overnachten in Volcanoes National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Bij het Volcanoes National Park zijn verschillende opties om te overnachten. Je kunt een accommodatie boeken in het <a href=\"https://www.booking.com/hotel/us/kilauea-lodge-amp-restaurant.en.html?aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=volcanoeskilauea\" target=\"_blank\" rel=\"noopener\">Kilauea Lodge and Restaurant</a>. Je logeert hier vlakbij het park. Een ideale uitvalsbasis om het park te verkennen. Wil je echt in het park overnachten? Dan is <a href=\"https://hawaiivolcanohouse.com/\" target=\"_blank\" rel=\"noopener\">Volcano House</a> een goede optie. Je slaapt hier vlakbij de vulkaan.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner][vc_custom_heading text=\"Wat te doen in Volcanoes National Park\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Volcanoes National Park biedt voldoende mogelijkheden qua bezienswaardigheden. Je kunt in principe in een dag veel zien in het park, maar mocht je ook een aantal wandelingen willen maken, neem dan iets meer tijd. Een aantal tips voor activiteiten en bezienswaardigheden in Volcanoes National Park.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"25px\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/2\"][fullwidth_row content_width=\"70%\"][vc_custom_heading text=\"Crater Rim\" font_container=\"tag:h3|font_size:30|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_single_image image=\"15067\" img_size=\"large\"][vc_column_text]De makkelijkste manier om Volcanoes National Park te verkennen is via de Crater Rim Drive. De rondweg door het park biedt je de mogelijkheden om onderweg van alles te zien en te stoppen bij bezienswaardigheden of wandelingen. Je bent ongeveer 1-2 uur onderweg in de auto. Stop bijvoorbeeld bij het Jaggar Museum om meer te weten te komen over vulkanen of ga eruit bij verschillende uitkijkpunten om de vulkanen te bekijken.[/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Kilauea outlook\" font_container=\"tag:h3|font_size:30|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_single_image image=\"15064\" img_size=\"large\"][vc_column_text]Een prachtige plek om uit te kijken over een actieve vulkaan: de Kilauea Outlook. Vanaf hier kun je vulkaan goed zien. Vooral in de ochtend en avond een goede plek om dit natuurfenomeen te bekijken.[/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/2\"][fullwidth_row content_width=\"70%\"][vc_custom_heading text=\"Chain of Craters Road\" font_container=\"tag:h3|font_size:30|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_single_image image=\"15066\" img_size=\"large\"][vc_column_text]Een andere manier om het park te verkennen is via de Chain of Craters Road. Een 30 kilometer lange weg die je langs verschillende kraters brengt. Overigens is er altijd een kans dat de weg onderbroken wordt door kolkende lava stromen. Je kunt de volgende kraters zien onderweg: Lua Manu, Pauahi en Kealakomo. Onderweg heb je de mogelijkheden om verschillende wandelingen te maken.[/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Visitor Center\" font_container=\"tag:h3|font_size:30|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_single_image image=\"15068\" img_size=\"large\"][vc_column_text]Wil je meer weten over vulkanen? Dan is een bezoek aan het bezoekerscentrum aan te raden. Het centrum is dagelijks geopend en biedt je daarnaast ook alle informatie voor wandelingen en condities van de routes. Er draait regelmatig een film over het ontstaan van het park.[/vc_column_text][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Trails in Volcanoes National Park\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"Ontdek het park op een van de wandelpaden\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"15071\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelen in Volcanoes National Park\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]Hoewel je het misschien niet verwacht, kun je toch goed wandelen in het Volcanoes National Park. Een voorbeeld van een mooie route is de Devastation Trail. Een makkelijk toegankelijke route van 1.6 kilometer langs de restanten van de uitbarsting van de Kilauea in 1959. Meer weten over de flora en fauna in Volcanoes National Park? Wandel dan de Kipukapuaulu Trail. In 2 kilometer kom je meer te weten over de zeldzame planten en dieren in het park.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]<strong>24/7 geopend, 7 dagen per week</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: hele jaar[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]7 daagse pas voor auto's: $30\r\n7 daagse pas voor voetgangers: $15[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Volcanoes National Park\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"Vulkanische landschappen\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"15074\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Meer nationale parken\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:4738,4714,4689,4792\"][/vc_column][/vc_row]","post_title":"Volcanoes National Park","post_link":"https://www.heyusa.com/nl/volcanoes-national-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"volcanoes national park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/02/volcanoes-national-park-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Volcanoes National Park","post_tags":"Hawaii","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%inline_featured_image%":"0","%_edit_lock%":"1694873276:2","%_edit_last%":"2","%_thumbnail_id%":"15065","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Volcanoes National Park","%_yoast_wpseo_metadesc%":"In Hawaii ligt het Volcanoes National Park. Tips voor een bezoek aan het Volcanoes National Park.","%_yoast_wpseo_linkdex%":"81","%_wpgmp_location_address%":"Hawaii Volcanoes National Park, HI 96785, Verenigde Staten","%_wpgmp_location_city%":"Hawaii Volcanoes National Park","%_wpgmp_location_state%":"Hawaii","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"19.4290543","%_wpgmp_metabox_longitude%":"-155.2568892","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_primary_category%":"225","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1694873401","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Volcanoes National Park","taxonomy=post_tag":"Hawaii","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""}},"id":15062,"infowindow_disable":false},{"source":"post","title":"NoMo SoHo","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Een kamer in het #wow hotel NoMo SoHo in New York City.\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/02/Nomo-Soho-Premium-King-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">NoMo SoHo</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"Alleen al voor het uitzicht vanuit de Delfts blauwe kamers, wil je hier logeren. Het NoMo in de wijk SoHo is #wow. ","address":"9 Crosby St, New York, NY 10013, Verenigde Staten","location":{"lat":"40.719835362954925","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-74.00008498650817","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/hotels/overnachten-in-new-york-city/nomo-soho/","zoom":12,"extra_fields":{"post_excerpt":"Alleen al voor het uitzicht vanuit de Delfts blauwe kamers, wil je hier logeren. Het NoMo in de wijk SoHo is #wow. ","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"#wow hotel in SoHo\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][ultimate_heading main_heading=\"9 Crosby Street, SoHo, Manhattan\" heading_tag=\"div\" main_heading_font_family=\"font_family:Oswald|font_call:Oswald\" main_heading_font_size=\"desktop:30px;\" main_heading_line_height=\"desktop:35px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"NoMo SoHo Hotel\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"$$$\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]De sfeer zit er al meteen goed in wanneer je naar de lobby van het NoMo SoHo wandelt. Door een haag van weelderig groene planten, beland je in een #coole lobby met neon, grote schilderijen met moderne kunst en veel kleur. Zo stoer en kleurrijk de publieke ruimtes zijn, zoals de bar, het restaurant, zo sereen en zacht zijn de hotelkamers. De Delfts Blauwe vloerbedekking en kussens met antiek blauw patroon geven de overwegende lichte en rustige kamer een kleurknaller. De kamer is een heeft tikkeltje Franse Louis XIV-stijl in moderne uitvoering. Veel wit en lichte tinten, om de knalblauwe vloerbedekking natuurlijk in evenwicht te brengen. En dan... dat uitzicht. Alleen al daarvoor wil je hier logeren![/vc_column_text][ultimate_heading main_heading=\"Geselecteerd door Hey!USA\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]NoMo SoHo is door Hey!USA geselecteerd omdat dit een hotel is met een eigen, unieke stijl. Glitter en glamour wordt afgewisseld met een industri\u00eble touch. De kamers zijn ruim en licht met geweldig uitzicht op de skyline van New York. Het ultieme Big Apple gevoel in een stoer hotel in het hippe SoHo.[/vc_column_text][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fnomo-soho.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dhotelcollection-hotelpage-nomo-soho|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"14776,14777,14767,14768,14769,14770,14771,14772,14779,14773,14775,14774,14778\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"14773\" img_size=\"large\" add_caption=\"yes\" style=\"vc_box_shadow_3d\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]De wijk SoHo is \u00e9\u00e9n van de hipste van New York. In de buurt kun je geweldig shoppen, er zijn talloze hotspots, cocktailbars en om de hoek begint Chinatown.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Toplocatie in SoHo\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"Gratis WiFi\"][thb_iconlist icon=\"fas fa-glass-cheers\" list_content=\"Bar\"][thb_iconlist icon=\"fas fa-binoculars\" list_content=\"Rooftop\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Comfortabele bedden\"][thb_iconlist icon=\"fas fa-running\" list_content=\"Gym\"][thb_iconlist icon=\"fas fa-utensils\" list_content=\"Restaurant\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fnomo-soho.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dhotelcollection-hotelpage-nomo-soho|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Andere hotels in New York City:\" main_heading_color=\"#b34a4c\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"25px\"][thb_postgrid style=\"style4\" columns=\"4\" source=\"size:8|post_type:post|categories:109\"][/vc_column][/vc_row]","post_title":"NoMo SoHo","post_link":"https://www.heyusa.com/nl/hotels/overnachten-in-new-york-city/nomo-soho/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Een kamer in het #wow hotel NoMo SoHo in New York City.\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/02/Nomo-Soho-Premium-King-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Overnachten in New York City","post_tags":"New York","%inline_featured_image%":"0","%_edit_lock%":"1714570669:2","%_edit_last%":"2","%_yoast_wpseo_primary_category%":"109","%_thumbnail_id%":"14764","%_hide_featured%":null,"%_wpgmp_location_address%":"9 Crosby St, New York, NY 10013, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.719835362954925","%_wpgmp_metabox_longitude%":"-74.00008498650817","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"13\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%post-primary-category%":"auto","%featured_image_override%":"off","%standard-featured-credit%":"Brennan McNichol - NoMo SoHo","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_focuskw%":"made hotel","%_yoast_wpseo_metadesc%":"Dit #wow hotel straalt glitter en glamour uit. ModernHaus SoHo is een hotel \u00e0 la Sex and The City. Een bijzonder hotel met allure.","%_yoast_wpseo_linkdex%":"41","%post_source%":[{"title":"NoMo SoHo","post_source_url":"https://www.nomosoho.com"}],"%_yoast_indexnow_last_ping%":"1678544473","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%executive_summary%":"Delfts blauw past bij jou!","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Overnachten in New York City","taxonomy=post_tag":"New York","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png"},"id":14763,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png","name":"Hotels","id":"13","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"High Roller in Las Vegas","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"High Roller Linq Promenade\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/01/high-roller-las-vegas-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">High Roller in Las Vegas</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"Boottocht van 90 minuten over de Hudson en East River","address":"3545 S Las Vegas Blvd, Las Vegas, NV 89109, Verenigde Staten","location":{"lat":"36.1176324","city":"Las Vegas","state":"Nevada","country":"Verenigde Staten","lng":"-115.168294","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/high-roller-las-vegas/","zoom":12,"extra_fields":{"post_excerpt":"Boottocht van 90 minuten over de Hudson en East River","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"30px\"][vc_custom_heading text=\"High Roller\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Van verre zie je hem al boven de Linq Promenade uitsteken; de High Roller. Het reuzenrad is een van de grootste ter wereld en natuurlijk kan er in Las Vegas niet een ontbreken. Met een hoogte van 168 meter geeft de High Roller natuurlijk prachtige panoramische uitzichten over Vegas. Een van de dingen om toe te voegen aan je lijstje met bezienswaardigheden in Las Vegas.[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf $23 voor een volwassene[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf $8,50 voor een kind[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612949537564{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"High Roller Las Vegas\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Heb je geen hoogtevrees? Stap dan in het reuzenrad om Las Vegas vanuit de lucht te bekijken. In ongeveer 30 minuten zie je de contouren van de stad die omringd wordt door een woestijnlandschap. Aan het reuzenrad zitten 28 cabins vanwaaruit je een 360 graden overzicht hebt. In zo'n cabin kunnen maximaal 40 personen. Tijdens het rondje hoor je via een tv informatie over wat je in de omgeving ziet. Je vindt The High Roller op de <a href=\"https://www.heyusa.com/nl/linq-promenade/\">Linq Promenade</a>. Een plek net buiten The Strip waar je kunt shoppen, lekker uit eten kunt en kunt genieten van activiteiten of shows.[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"High Roller Las Vegas\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Stap in \u00e9\u00e9n van de 28 cabins om Las Vegas te bekijken\" font_container=\"tag:div|font_size:45|text_align:center\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"14662\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tickets voor de High Roller\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Er zijn twee verschillende soorten tickets voor The High Roller; dag tickets en anytime/nighttime tickets. Je kunt je tickets van te voren online kopen.[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Flas-vegas-l58%2Fthe-high-roller-ride-at-the-linq-ticket-t270522%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dhighrollerlasvegas\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_custom_heading text=\"Tickets voor The High Roller met Happy Hour\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Tijdens het spectaculaire uitzicht genieten met een drankje? Dan kun je speciale tickets kopen voor The High Roller met een Happy Hour. Tijdens de rit heb je onbeperkt toegang tot drankjes.[/vc_column_text][ult_buttons btn_title=\"Bestel je Happy Hour tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Flas-vegas-l58%2Fthe-high-roller-ride-at-the-linq-ticket-t436735%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dhighrollerlasvegashappyhour\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>3545 S Las Vegas Blvd</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Maandag - donderdag: 14.00-00.00 uur\r\nVrijdag - zondag: 12.00-00.00 uur</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Uitzicht over Las Vegas\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Bekijk de contouren van de stad\" font_container=\"tag:div|font_size:45|text_align:center\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"14664\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Meer foto's van de High Roller\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][thb_image_slider images=\"14663,14661,14666,14667\"][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Andere leuke artikelen\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:14406,13761,12584,2388\"][/vc_column][/vc_row]","post_title":"High Roller in Las Vegas","post_link":"https://www.heyusa.com/nl/high-roller-las-vegas/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"High Roller Linq Promenade\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/01/high-roller-las-vegas-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Las Vegas","post_tags":"Nevada","%_wpb_shortcodes_custom_css%":".vc_custom_1612949537564{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1675332788:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"65","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"14411","%_yoast_wpseo_focuskw%":"High Roller","%_yoast_wpseo_title%":"High Roller Las Vegas %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Het reuzenrad op de Linq Promenade kan niet ontbreken tijdens een bezoek aan Las Vegas. Bekijk hier de tickets voor The High Roller Las Vegas","%_yoast_wpseo_linkdex%":"36","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"High Roller Las Vegas\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"3545 S Las Vegas Blvd, Las Vegas, NV 89109, Verenigde Staten","%_wpgmp_location_city%":"Las Vegas","%_wpgmp_location_state%":"Nevada","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"36.1176324","%_wpgmp_metabox_longitude%":"-115.168294","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_primary_category%":"54","%_yoast_indexnow_last_ping%":"1677014842","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Bezienswaardigheden Las Vegas","taxonomy=post_tag":"Nevada","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":14660,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Zon, zee &#038; strand in Brooklyn","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coney Island\" width=\"300\" height=\"225\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/01/coney-island-beach-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Zon, zee &#038; strand in Brooklyn</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1071 5th Ave, New York, NY 10128, Verenigde Staten","location":{"lat":"40.7829796","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.9589706","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/stranden-brooklyn/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"25px\"][ultimate_heading main_heading=\"Zon, zee &amp; strand in Brooklyn\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]<strong>De zomers in New York zijn warm, temperaturen boven de 35 graden zijn geen uitzondering. De meeste locals kiezen ervoor om de stad te verlaten. Gelukkig kunnen de achterblijvers richting de stranden van New York. Stranden? In Brooklyn zijn er 3 plekken waar je kunt genieten van zon, zee en strand.\u00a0</strong>\r\n\r\n<strong>\u00a0</strong>[/vc_column_text][vc_empty_space height=\"25px\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Manhattan Beach\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\" margin_design_tab_text=\"\"][/ultimate_heading][ultimate_heading main_heading=\"Het mooiste strand van Brooklyn?\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"14518\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Stranden in Brooklyn\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\" margin_design_tab_text=\"\"][/ultimate_heading][ultimate_heading main_heading=\"De plek om even af te koelen in de zomer\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Brighton Beach\" heading_tag=\"h3\" main_heading_color=\"#223656\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][ultimate_heading main_heading=\"Brooklyn\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:21px;\"][/ultimate_heading][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>Brighton Beach</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-subway\"]<strong>Dekalb Avenue | Q | B</strong>[/ultimate_icon_list_item][/ultimate_icon_list][vc_column_text]In het zuidelijke gedeelte van Brooklyn, grenzend aan Coney Island, ligt Brighton Beach. Ooit in 1645 gekocht van de indianen voor een pistool, een deken en een waterkoker. Destijds vooral een terrein vol zand waar diverse boerderijen op stonden. In 1868 werd het eerste resort gebouwd op het terrein Brighton Beach, in een periode waarin Coney Island steeds meer in verval raakte. Ook een eigen amusementsgebied \u2018Brighton Pike\u2019 kon niet ontbreken. Na een fatale brand in 1919, bleef alleen het strand over als trekpleister voor de buurt. De wijk kreeg de bijnaam \u2018Little Odessa\u2019, naar een stad in Oekra\u00efne vanwege de vele Joodse immigranten uit Rusland en Oekra\u00efne die na de Tweede Wereld Oorlog richting Brooklyn kwamen.\r\n\r\nHoewel het dus op relatief korte afstand ligt van Coney Island is Brighton Beach een stuk relaxter om naar het strand te gaan. Je hebt niet het lawaai van alle attracties aan de boardwalk bij Coney Island, maar een relatief rustig plekje om te genieten met mooi weer. Klaar met een dagje strand? Duik dan nog even Little Odessa in voor goede restaurants en nachtclubs.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Coney Beach\" heading_tag=\"h3\" main_heading_color=\"#223656\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][ultimate_heading main_heading=\"Brooklyn\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:21px;\" margin_design_tab_text=\"\"][/ultimate_heading][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>Coney Island\u00a0</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-subway\"]<strong>Coney Island - Stillwell Avenue | D | F | N | Q</strong>[/ultimate_icon_list_item][/ultimate_icon_list][vc_column_text]Het meest bekende strand van Brooklyn en New York: Coney Beach. Je vindt de wijk in het zuidwestelijke deel van Brooklyn. De eerste vormen van toerisme en vermaak begonnen al rond 1860 in de buurt. Twintig jaar later waren daar al amusementsparken te vinden, parken met iconische attracties die nog steeds in de wijk te vinden zijn. Tot net na de Tweede Wereldoorlog waren het nog gloriedagen voor Coney Island. Langzamerhand werd de wijk geteisterd door sociale problemen. Pas tegen het einde van de jaren \u201980, begin jaren \u201990 werd de wijk langzaam weer de wijk zoals we die nu kennen. Een wijk met een nostalgisch tintje door de vele oorspronkelijke attracties en sfeer die er nog hangt.\r\n\r\nHet iconische <a href=\"https://www.heyusa.com/nl/new-york/coney-island/\">Coney Island</a> is ongeveer 5 kilometer lang en bevindt zich aan de Coney Island Boardwalk. Zwemmen in de zee kan tussen 10.00 uur en 18.00 uur wanneer de lifeguards aanwezig zijn. Coney Island Beach biedt meer dan alleen zee en strand, want de omringende wijk Coney Island biedt tal van vermaak en vele plekken om te eten. Vergeet niet de beroemde hotdog van Nathan\u2019s Famous te proberen of stap in de befaamde Wonder Wheel voor een rondje reuzenrad.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Manhattan Beach\" heading_tag=\"h3\" main_heading_color=\"#223656\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][ultimate_heading main_heading=\"Brooklyn\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:21px;\" margin_design_tab_text=\"\"][/ultimate_heading][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>Manhattan Beach</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-subway\"]<strong>Sheepshead Bay | B</strong>[/ultimate_icon_list_item][/ultimate_icon_list][vc_column_text]Manhattan Beach was ooit het meest luxe van de drie grote resorts die na de Amerikaanse Burgeroorlog uit de grond werden gestampt op Coney Island. Met de komst van het Manhattan Beach Hotel (1877) en later het nog grotere Oriental Hotel (1880) werd Manhattan Beach destijds een plek waar duizenden bezoekers op af kwamen. Tel daarbij de concerten van beroemde componisten in deze hotels en de vuurwerkshows op het strand en Manhattan Beach werd een beroemde zomerbadplaats. Helaas liep de hotelindustrie terug in het gebied, waarop New York City Parks de wijk omtoverde tot een woonwijk en Manhattan Beach Park. Om de druk van Coney Island en Brighton Beach te verlichten, was daar Manhattan Beach.\r\n\r\nHoewel vaak gedacht wordt dat Coney Beach het beste strand is van Brooklyn, gaat deze titel toch naar Manhattan Beach. Populair in de zomer, is Manhattan Beach geschikt voor families en als je op zoek bent naar een actieve dag in de zon. Je vindt op Manhattan Beach plekken om te barbecue\u00ebn, picknicken en sporten. Een ideale combi tussen relaxen in de zon, lekker eten en actief zijn.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][vc_empty_space height=\"75px\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Brighton Beach \" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\" margin_design_tab_text=\"\"][/ultimate_heading][ultimate_heading main_heading=\"Perfecte escape op een warme dag in NYC\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"14516\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ook leuk in New York City:\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][fullwidth_row][thb_postgrid columns=\"4\" source=\"post_type:post|by_id:1594,1312,408,1559\"][/vc_column][/vc_row]","post_title":"Zon, zee &#038; strand in Brooklyn","post_link":"https://www.heyusa.com/nl/stranden-brooklyn/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coney Island\" width=\"300\" height=\"225\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/01/coney-island-beach-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Stedentrips","post_tags":"New York","%_wpb_shortcodes_custom_css%":".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1675175450:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Stranden in Brooklyn","%_yoast_wpseo_title%":"Stranden in Brooklyn %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Ben je in de zomer in New York en wil je ergens zwemmen? Check dan deze stranden in Brooklyn om een duik te nemen in de zee.","%_yoast_wpseo_linkdex%":"77","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"1071 5th Ave, New York, NY 10128, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7829796","%_wpgmp_metabox_longitude%":"-73.9589706","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_primary_category%":"62","%post_via%":{"1":{"title":"","post_source_url":""}},"%_yoast_indexnow_last_ping%":"1677014849","%_last_editor_used_jetpack%":"classic-editor","%_thumbnail_id%":"14520","taxonomy=category":"Stedentrips","taxonomy=post_tag":"New York","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":14512,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Unieke attractie en meer op de Linq Promenade in Las Vegas","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Linq Promenade\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/01/linq-promenade-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Unieke attractie en meer op de Linq Promenade in Las Vegas</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"3545 S Las Vegas Blvd, Las Vegas, NV 89109, Verenigde Staten","location":{"lat":"36.1177801","city":"Las Vegas","state":"Nevada","country":"Verenigde Staten","lng":"-115.1725748","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/linq-promenade/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"25px\"][vc_custom_heading text=\"Ontdek de verschillende mogelijkheden op de Linq Promenade\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<div class=\"page\" title=\"Page 1\">\r\n<div class=\"section\">\r\n<div class=\"layoutArea\">\r\n<div class=\"column\">\r\n\r\nOke, de Strip is natuurlijk de grootste publiekstrekker in Las Vegas. Maar een ander bezienswaardigheid die niet kan ontbreken tijdens een bezoek aan Las Vegas is de Linq Promenade. Een geweldige plek in Vegas om unieke attracties, verschillende winkels en restaurants te bezoeken. Vanuit de verte zie je een van de hoofdattracties al er bovenuit steken; de High Roller. Het gigantische reuzenrad dat je een panoramisch uitzicht biedt op The Strip. Is dit iets te hoog voor je? Dan zijn er nog tal van andere bezienswaardigheden of winkels en restaurants om te bezoeken. Een aantal tips om alles uit een bezoek aan de Linq Promenade te halen. <span style=\"font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen-Sans, Ubuntu, Cantarell, 'Helvetica Neue', sans-serif;\">\u00a0</span>\r\n\r\n</div>\r\n</div>\r\n</div>\r\n</div>\r\n[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Gratis[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612950540814{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Wat is precies de Linq Promenade?\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<div class=\"page\" title=\"Page 1\">\r\n<div class=\"section\">\r\n<div class=\"layoutArea\">\r\n<div class=\"column\">\r\n<p style=\"text-align: center;\">De naam Linq Promenade kan verwarrend zijn wanneer je eerder in Las Vegas bent geweest. Het gebied heeft de afgelopen jaren verschillende namen gehad. Linq komt van de naam van het casino dat grenst aan de promenade. Sinds eind 2014 heet het gebied The Linq Promenade. Wat is de Linq Promenade precies? Het is eigenlijk een wandelgebied in de buitenlucht waar je veel restaurants, winkels, bars, shows en andere attracties kunt vinden.</p>\r\n\r\n</div>\r\n</div>\r\n</div>\r\n</div>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"High Roller op de Linq Promenade\" font_size=\"55\" line_height=\"60\" font_color=\"#ffffff\"][vc_custom_heading text=\"Een van de hoogste ter wereld\" font_container=\"tag:h3|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"14411\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Attractie op de Linq Promenade\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De grootste publiekstrekker op de Linq Promenade, ook letterlijk, is het reuzenrad <a href=\"https://www.heyusa.com/nl/high-roller-las-vegas/\">The High Roller</a>. Dit is een van de hoogste ter wereld, alleen in Dubai vind je een hogere. Het reuzenrad, met een hoogte van 168 meter, heeft 28 cabins waar ongeveer 40 mensen in kunnen. Je krijgt vanuit de cabins een 360 graden uitzicht over <a href=\"https://www.heyusa.com/nl/las-vegas/the-strip-las-vegas/\">The Strip</a> en Las Vegas.\r\n\r\nEen andere attractie, iets meer door adrenaline junkies, is de <a href=\"https://www.heyusa.com/nl/las-vegas/fly-linq-zipline/\">Fly Linq Zipline</a>. Laat je vastmaken bij de start op de Las Vegas Boulevard en vlieg op een hoogte van 12 verdiepingen boven de LINQ Promenade. Geniet van het uitzicht over de Linq Promenade wanneer via je een zipline door Las Vegas gaat. Je kunt zittend of als een superheld via de zipline de rit maken.\r\n\r\nEen populaire plek is de <a href=\"https://www.brooklynbowl.com/\" target=\"_blank\" rel=\"noopener\">Brooklyn Bowl</a>. Niet alleen de plek om te bowlen in Las Vegas, je kunt er ook gezellig iets eten of drinken. Daarnaast zijn er tal van shows en andere evenementen.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Shoppen op de Linq Promenade\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<div class=\"page\" title=\"Page 1\">\r\n<div class=\"section\">\r\n<div class=\"layoutArea\">\r\n<div class=\"column\">\r\n\r\nOp de Linq Promenade heb je verschillende mogelijkheden om te <a href=\"https://www.caesars.com/linq/things-to-do/shopping\" target=\"_blank\" rel=\"noopener\">shoppen</a>. Wat denk je van iconische Harley Davidson producten? Of de cookies van Honolulu Cookie Company. Ook voor kleding zijn er verschillende winkels waar je terecht kunt. Daarnaast zijn er een aantal winkels met accessoires en natuurlijk kunnen gift shops voor souvenirs ook niet ontbreken op de Linq Promenade.\r\n\r\n</div>\r\n</div>\r\n</div>\r\n</div>\r\n<span style=\"font-weight: 400;\">\u00a0</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Restaurants Linq Promenade\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<div class=\"page\" title=\"Page 1\">\r\n<div class=\"section\">\r\n<div class=\"layoutArea\">\r\n<div class=\"column\">\r\n\r\nMet meer dan 35 restaurants heb je een goede reden om nog langer op de Linq Promenade te blijven. Enkele favorieten zijn:\r\n<ul>\r\n \t<li>I Love Sugar: eigenlijk lijkt dit een gigantische snoepwinkel, maar je kunt er ook snoep gerelateerde drankjes drinken. Enorm fotogeniek overigens</li>\r\n \t<li>American Beer: Bier proeven uit alle <a href=\"https://www.heyusa.com/nl/alle-50-staten-van-amerika/\">staten van Amerika</a>? Dan moet je naar American Beer</li>\r\n \t<li>Favorite Bistro: Eten in Franse stijl met een Amerikaans tintje</li>\r\n \t<li>Minus5 Icebar: Midden in de woestijn drankjes doen in de kou? Geniet bij Minus5 Icebar van verschillende cocktails</li>\r\n \t<li>Gordon Ramsay Fish and Chips: Een klassieke fish and chips haal je bij het restaurant van Gordon Ramsay op de Linq Promenade</li>\r\n \t<li>In-N-Out Burger: De plek om een burger te scoren</li>\r\n</ul>\r\n</div>\r\n</div>\r\n</div>\r\n</div>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Brooklyn Bowl\" font_size=\"55\" line_height=\"60\" font_color=\"#ffffff\"][vc_custom_heading text=\"Bowlen, eten en drinken\" font_container=\"tag:h3|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"14410\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Las Vegas\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:13191,12584,11542,11382\"][/vc_column][/vc_row]","post_title":"Unieke attractie en meer op de Linq Promenade in Las Vegas","post_link":"https://www.heyusa.com/nl/linq-promenade/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Linq Promenade\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/01/linq-promenade-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Las Vegas","post_tags":"Nevada","%_wpb_shortcodes_custom_css%":".vc_custom_1612950540814{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"2","%_edit_lock%":"1718097499:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"54","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"14412","%_yoast_wpseo_focuskw%":"Linq Promenade","%_yoast_wpseo_metadesc%":"Linq Promenade in Vegas is een leuke plek met attracties, winkels, restaurants en vele events. Tips voor een bezoek aan Linq Promenade","%_yoast_wpseo_linkdex%":"80","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"3545 S Las Vegas Blvd, Las Vegas, NV 89109, Verenigde Staten","%_wpgmp_location_city%":"Las Vegas","%_wpgmp_location_state%":"Nevada","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"36.1177801","%_wpgmp_metabox_longitude%":"-115.1725748","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_primary_category%":"54","%_yoast_indexnow_last_ping%":"1718097103","%_last_editor_used_jetpack%":"classic-editor","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","taxonomy=category":"Bezienswaardigheden Las Vegas","taxonomy=post_tag":"Nevada","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":14406,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Pearl Harbor","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pearl Harbor\" width=\"300\" height=\"209\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/01/memorials-pearl-harbor-300x209.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Pearl Harbor</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"Boottocht van 90 minuten over de Hudson en East River","address":"Pearl Harbor, Hawa\u00ef, Verenigde Staten","location":{"lat":"21.3511958","state":"Hawa\u00ef","country":"Verenigde Staten","lng":"-157.9801523","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/pearl-harbor/","zoom":12,"extra_fields":{"post_excerpt":"Boottocht van 90 minuten over de Hudson en East River","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"30px\"][vc_custom_heading text=\"Pearl Harbor\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Pearl Harbor in Hawaii, nog steeds een belangrijke plek. Op 7 december 1941 werd de marinebasis compleet verrast door het Japanse leger. Een belangrijke gebeurtenis in de Amerikaanse geschiedenis die ook de Tweede Wereldoorlog be\u00efnvloedde. Benieuwd wat er precies gebeurde op die 7 december en of Pearl Harbor nog steeds te bezoeken is?[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Gratis, een tour vanaf 55 euro[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612949537564{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Pearl Harbor: wat gebeurde er op 7 december 1941?\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Op de vroege ochtend van 7 december 1941 werd de Amerikaanse marine in Oahu in Hawaii verrast door het Japanse leger. Op 25 november was een Japanse vloot vertrokken uit Japan en 5 dagen voor de aanval op Pearl Harbor werd alle communicatie stop gezet, complete radiostilte om zo onopgemerkt te blijven. Op zo'n 350 kilometer voor de kust van Oahu stegen op 7 december verschillende vliegtuigen op die de Amerikaanse marine compleet verrasten in de haven. De verliezen waren dan ook groot, 8 schepen zonken of raakten beschadigd en meer dan 2400 Amerikanen kwamen om het leven. Aan de Japanse kant waren de verliezen een stuk minder. Slechts 29 vliegtuigen werden neergehaald en 65 mannen kwamen om het leven. De Amerikanen bleken geluk te hebben dat 3 vliegdekschepen al de haven uit waren. Uiteindelijk konden 6 van de 8 getroffen schepen gerepareerd worden en alsnog gebruikt worden in de oorlog. Op 8 december 1941 verklaarde Franklin D. Roosevelt de oorlog aan Japan en daarmee deelname aan de Tweede Wereldoorlog. Pearl Harbor wordt nog steeds gezien als een van de belangrijkste gebeurtenissen in de moderne geschiedenis en een belangrijk keerpunt in de Tweede Wereldoorlog.[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Pearl Harbor USS Arizona\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Bezoek het USS Arizona Memorial\" font_container=\"tag:div|font_size:45|text_align:center\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"14304\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Pearl Harbor bezoeken\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Je kunt Pearl Harbor op Oahu nog steeds bezoeken. Het slagschip USS Arizona, die op 7 december zonk, ligt nog op de bodem. Het USS Arizona Memorial herdenkt aan de 1177 mariniers die omkwamen bij de aanval op de USS Arizona. Voor een bezoek aan het memorial dien je een ticket aan te schaffen, de toegang is wel gratis. Ook het slagschip USS Missouri (die nog gebruikt werd in de laatste maanden van de oorlog) en de onderzee\u00ebr USS Bowfin,\u00a0 zijn te bezoeken. Voor een bezoek geldt dezelfde regeling. Het Peal Harbor Visitor Center is gratis te bezoeken, zonder ticket.[/vc_column_text][vc_custom_heading text=\"Tickets voor Pearl Harbor\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Pearl Harbor bezoeken en direct ook de stad Honolulu zien? Dan is <a href=\"https://www.getyourguide.com/oahu-l4966/honolulu-pearl-harbor-uss-arizona-and-city-tour-t401010/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=pearlharborintekst\" target=\"_blank\" rel=\"noopener\">deze tour</a> perfect voor je. Je bezoekt de belangrijkste historische bezienswaardigheden van Honolulu. De tour gaat onder andere langs Pearl Harbor, het USS Arizona Memorial, maar ook Iolani Palace, Kawaiahao Church en het Hawaii State Capitol. Je stapt in Pearl Harbor aan boord van een marineboot die je een rondleiding geeft door de haven langs Battleship Row. Daarna gaat de tour door naar het centrum van Honolulu om de belangrijkste bezienswaardigheden te bekijken.[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Foahu-l4966%2Fhonolulu-pearl-harbor-uss-arizona-and-city-tour-t401010%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dpearlharborbanner\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>1 Arizona Memorial Pl, Honolulu</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Dagelijks meestal tussen 07.00-17.00 uur</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"USS Bowfin\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Bezoek de USS Bowfin en de USS Missouri die in de haven liggen\" font_container=\"tag:div|font_size:45|text_align:center\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"14305\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Andere leuke artikelen\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:13961,13822,12854,6704\"][/vc_column][/vc_row]","post_title":"Pearl Harbor","post_link":"https://www.heyusa.com/nl/pearl-harbor/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pearl Harbor\" width=\"300\" height=\"209\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/01/memorials-pearl-harbor-300x209.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden","post_tags":"Hawaii","%_wpb_shortcodes_custom_css%":".vc_custom_1612949537564{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1678544143:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"65","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"14303","%_yoast_wpseo_focuskw%":"Pearl Harbor","%_yoast_wpseo_title%":"Pearl Harbor%%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een belangrijke plek in de Amerikaanse geschiedenis is Pearl Harbor op Oahu Hawaii. Lees meer over de gebeurtenissen op 7 december 1941 en tips voor je bezoek.","%_yoast_wpseo_linkdex%":"79","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Oahu\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"Pearl Harbor, Hawa\u00ef, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Hawa\u00ef","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"21.3511958","%_wpgmp_metabox_longitude%":"-157.9801523","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_primary_category%":"65","%_yoast_indexnow_last_ping%":"1677014859","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Bezienswaardigheden","taxonomy=post_tag":"Hawaii","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":14300,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Sliding Rock North Carolina","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sliding Rock North Carolina\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/01/sliding-rock-nc-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Sliding Rock North Carolina</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"Boottocht van 90 minuten over de Hudson en East River","address":"Sliding Rock, North Carolina 28768, Verenigde Staten","location":{"lat":"35.3114991","state":"North Carolina","country":"Verenigde Staten","lng":"-82.7872344","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/sliding-rock/","zoom":12,"extra_fields":{"post_excerpt":"Boottocht van 90 minuten over de Hudson en East River","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"30px\"][vc_custom_heading text=\"Sliding Rock\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In North Carolina vind je de waterval Sliding Rock. Een heerlijke verkoeling op warme dagen, want Sliding Rock heet niets voor niets zo. Het is een natuurlijke glijbaan van rotsen waar je af kunt glijden. Het ligt in het Pisgah National Forest in de buurt van Brevard. Door de flauwe helling en de lengte van 18 meter is het een hele fijne natuurlijke attractie geworden, zeker op warme dagen.[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf $5 per persoon[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612949537564{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Glijden vanaf Sliding Rock\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Pisgah National Forest is een populair recreatiegebied. Sliding Rock wordt in de zomermaanden veelvuldig bezocht. Het gebied is ingesteld op bezoekers, zo zijn er uitkijkplatformen, trappen en relingen om je aan vast te houden. Rondom Sliding Rock vind je een toilet en kleedkamer. Ook is er regelmatig een parkwachter aanwezig. Kinderen moeten een bepaalde grootte hebben om te mogen glijden, anders moeten ze op schoot bij een volwassene. Zijn er geen parkwachters? Dan is het glijden op eigen risico.[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Sliding Rock met herfstkleuren\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Niet meer van de glijbaan, maar wel genieten van prachtige kleuren\" font_container=\"tag:div|font_size:45|text_align:center\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"14269\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Kosten Sliding Rock\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In de zomermaanden is Sliding Rock een populaire trekpleister. Forest Service vraagt een vergoeding van $5 per persoon wanneer er parkwachters/strandwachten aanwezig zijn. Zij zijn aanwezig tussen Memorial Day en Labor Day. Kaartjes kunnen ter plekke gekocht worden.[/vc_column_text][vc_custom_heading text=\"Parkeren Sliding Rock\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Volg vanuit Pisgah Forest de 276 North East (naar Waynesville), daarna krijg je aan de linkerhand Sliding Rock. Parkeren kan op een groot terrein boven op de rots naast Highway 276.[/vc_column_text][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"In de buurt:\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Naast Sliding Rock heb je de mogelijkheid om andere watervallen in de regio te bekijken en diverse wandelingen te maken. Rijd je via Highway 276 dan kom je onderweg al verschillende watervallen tegen. Een populaire trail in het gebied is de Moore Cove Falls Trail waarbij je langs de waterval Looking Glass Falls komt. Heb je nog meer tijd? Dan kun je ook een stuk rijden van de <a href=\"https://www.heyusa.com/nl/blue-ridge-parkway-roadtrip/\">Blue Ridge Parkway</a>.[/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Andere leuke artikelen\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:4076,2150,8989,4714\"][/vc_column][/vc_row]","post_title":"Sliding Rock North Carolina","post_link":"https://www.heyusa.com/nl/sliding-rock/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sliding Rock North Carolina\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/01/sliding-rock-nc-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden","post_tags":"North Carolina","%_wpb_shortcodes_custom_css%":".vc_custom_1612949537564{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1672755462:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"65","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"14270","%_yoast_wpseo_focuskw%":"Sliding Rock North Carolina","%_yoast_wpseo_title%":"Sliding Rock North Carolina %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een populaire attractie in North Carolina is Sliding Rock. Een natuurlijke glijbaan van 18 meter lang midden in de bossen.","%_yoast_wpseo_linkdex%":"71","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Sliding Rock \"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"Sliding Rock, North Carolina 28768, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"North Carolina","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"35.3114991","%_wpgmp_metabox_longitude%":"-82.7872344","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_primary_category%":"65","%_yoast_indexnow_last_ping%":"1677014866","taxonomy=category":"Bezienswaardigheden","taxonomy=post_tag":"North Carolina","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":14268,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Met een vliegtuigje over Key Largo","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Vliegtuigje Key Largo\" width=\"300\" height=\"209\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/01/vliegen-florida-keys-300x209.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Met een vliegtuigje over Key Largo</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Overseas Hwy, Key Largo, FL, Verenigde Staten","location":{"lat":"25.1041194","city":"Key Largo","state":"Florida","country":"Verenigde Staten","lng":"-80.43066240000002","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/vliegen-over-key-largo/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Met een vliegtuigje over Key Largo\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_column_text]De omgeving vanuit de lucht of een uitzichtpunt bekijken is altijd een aanrader op reis. Op de Florida Keys raden we je aan om met een <a href=\"https://www.getyourguide.com/key-largo-l32151/miami-1-hour-key-largo-aerial-tour-with-spectacular-views-t352406/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=vliegtuigkeylargointekst\" target=\"_blank\" rel=\"noopener\">vliegtuigje over Key Largo</a> te vliegen. Stap in het vliegtuigje in Miami om het grootste eiland van de Florida Keys te bekijken, <a href=\"https://www.heyusa.com/nl/key-largo/\">Key Largo</a>. Vanuit de lucht heb je een prachtig uitzicht op Biscayne Bay, Biscayne National Park en de eilanden. In een uurtje zie je de contouren van de eerste eilanden van de Florida Keys.[/vc_column_text][vc_custom_heading text=\"Handige informatie voor het nemen van een vliegtuig over Key Largo\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<b>Duur:</b> 1\u00a0uur<b>\r\nPrijs</b><span style=\"font-weight: 400;\">: Vanaf 175 euro</span><span style=\"font-weight: 400;\">\r\n</span><b>Locatie</b><span style=\"font-weight: 400;\">: 14359 SW 127th St, Miami - let op! Opstappen is in Miami</span><span style=\"font-weight: 400;\">\r\n</span><b>Aantal vluchten:</b> Zo'n 8 per dag, vaak starten ze rond 11.00 uur en de laatste rond 18.00 uur\r\n<strong>Belangrijk:\u00a0</strong>Niet geschikt voor zwangere vrouwen of mensen die slecht ter been zijn[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fkey-largo-l32151%2Fmiami-1-hour-key-largo-aerial-tour-with-spectacular-views-t352406%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dvliegtuigkeylargobanner|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"20px\"][/vc_column][vc_column width=\"1/3\"][thb_image retina=\"retina_size\" box_shadow=\"medium-shadow\" thb_border_radius=\"10px\" image=\"12539\"][/thb_image][vc_empty_space height=\"20px\"][vc_column_text][/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Florida\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:12262,12074,12063,9784\"][/vc_column][/vc_row]","post_title":"Met een vliegtuigje over Key Largo","post_link":"https://www.heyusa.com/nl/vliegen-over-key-largo/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Vliegtuigje Key Largo\" width=\"300\" height=\"209\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/01/vliegen-florida-keys-300x209.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Florida Keys","post_tags":"Florida","%_edit_last%":"2","%_edit_lock%":"1685520254:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"168","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style3","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":{"2":{"title":"","post_source_url":""}},"%_yoast_wpseo_focuskw%":"Met een vliegtuigje over Key Largo","%_yoast_wpseo_metadesc%":"Bekijk Key Largo vanuit de lucht met een vliegtuigje. Stap in Miami in een klein vliegtuig en zie de eilanden vanuit de lucht.","%_yoast_wpseo_linkdex%":"73","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"key largo\"]","%_wpgmp_location_address%":"Overseas Hwy, Key Largo, FL, Verenigde Staten","%_wpgmp_location_city%":"Key Largo","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.1041194","%_wpgmp_metabox_longitude%":"-80.43066240000002","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"14335","%inline_featured_image%":"0","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1685520246","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Florida Keys","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":14334,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Duiken op Key Largo","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Duiker Key Largo\" width=\"300\" height=\"209\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/01/duiker-key-largo-300x209.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Duiken op Key Largo</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"103800 Overseas Hwy, Key Largo, FL 33037, Verenigde Staten","location":{"lat":"25.1413389","city":"Key Largo","state":"Florida","country":"Verenigde Staten","lng":"-80.39994999999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/duiken-key-largo/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Duiken op Key Largo\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_column_text]Benieuwd naar de onderwaterwereld bij het Florida Keys National Marine Sanctuary en het John Pennekamp Coral Reef State Park? Ga dan mee met een <a href=\"https://www.viator.com/nl-NL/tours/Key-Largo/Half-Day-Scuba-Diving-Trip-in-the-Florida-Keys/d23475-204315P1?pid=P00074479&amp;mcid=42383&amp;medium=link&amp;campaign=duikenkeylargointekst\" target=\"_blank\" rel=\"noopener\">tour om te duiken</a> in deze prachtige onderwaterwereld rondom <a href=\"https://www.heyusa.com/nl/key-largo/\">Key Largo</a>. Met een catamaran vaar je naar de naar twee verschillende gebieden, hier kun je beiden keren een duik maken. Je kunt meer dan honderden verschillende soorten vissen tegenkomen in de wateren rondom Key Largo. In principe moet je SCUBA gecertificeerd zijn om te duiken, maar je kunt contact opnemen voor eventuele andere mogelijkheden.[/vc_column_text][vc_custom_heading text=\"Handige informatie voor het duiken op Key Largo\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<b>Duur:</b> 3,5 uur<b>\r\nPrijs</b><span style=\"font-weight: 400;\">: Vanaf 108 euro</span><span style=\"font-weight: 400;\">\r\n</span><b>Locatie</b><span style=\"font-weight: 400;\">: 103800 Overseas Hwy</span><span style=\"font-weight: 400;\">\r\n</span><b>Openingstijden:</b> Vaak rond 08.30 en 13.00 uur\r\n<strong>Belangrijk:\u00a0</strong>SCUBA gecertificeerd zijn[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.viator.com%2Fnl-NL%2Ftours%2FKey-Largo%2FHalf-Day-Scuba-Diving-Trip-in-the-Florida-Keys%2Fd23475-204315P1%3Fpid%3DP00074479%26mcid%3D42383%26medium%3Dlink%26campaign%3Dduikenkeylargobanner|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"20px\"][/vc_column][vc_column width=\"1/3\"][thb_image retina=\"retina_size\" box_shadow=\"medium-shadow\" thb_border_radius=\"10px\" image=\"14317\"][/thb_image][vc_empty_space height=\"20px\"][vc_column_text][/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Florida\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:12262,12074,12063,9784\"][/vc_column][/vc_row]","post_title":"Duiken op Key Largo","post_link":"https://www.heyusa.com/nl/duiken-key-largo/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Duiker Key Largo\" width=\"300\" height=\"209\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/01/duiker-key-largo-300x209.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Florida Keys","post_tags":"Florida","%_edit_last%":"2","%_edit_lock%":"1685520112:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"168","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style3","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":{"2":{"title":"","post_source_url":""}},"%_yoast_wpseo_focuskw%":"Duiken op Key Largo","%_yoast_wpseo_metadesc%":"Bekijk het enige levende rif van Noord Amerika vanuit Key Largo. Met deze excursie ga je duiken bij het rif in Key Largo.","%_yoast_wpseo_linkdex%":"70","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"key largo\"]","%_wpgmp_location_address%":"103800 Overseas Hwy, Key Largo, FL 33037, Verenigde Staten","%_wpgmp_location_city%":"Key Largo","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.1413389","%_wpgmp_metabox_longitude%":"-80.39994999999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"14331","%inline_featured_image%":"0","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1685519982","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Florida Keys","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":14329,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Snorkelen in Key Largo","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Snorkelen Key Largo\" width=\"300\" height=\"209\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/01/snorkel-key-largo-300x209.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Snorkelen in Key Largo</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Overseas Hwy, Key Largo, FL, Verenigde Staten","location":{"lat":"25.1041194","city":"Key Largo","state":"Florida","country":"Verenigde Staten","lng":"-80.43066240000002","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/snorkelen-in-key-largo/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Snorkelen in Key Largo\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_column_text]Snorkelen in Key Largo! Maak een duik bij <a href=\"https://www.heyusa.com/nl/key-largo/\">Key Largo</a> om de onderwaterwereld te bekijken. Met deze tour ga je snorkelen bij het Florida Keys National Marine Sanctuary waar je prachtige riffen en vele soorten vissen ziet. Een tour die perfect is voor als je voor het eerst wilt snorkelen, maar ook voor mensen die al vaker hebben gesnorkeld. Bij de tour zit alle uitrusting inbegrepen met uitzondering van een snorkel, deze kun je op de locatie kopen. <a href=\"https://www.viator.com/nl-NL/tours/Key-Largo/Sundiver-Snorkel-Tours/d23475-116454P1?pid=P00074479&amp;mcid=42383&amp;medium=link&amp;campaign=snorkelenkeylargointekst\" target=\"_blank\" rel=\"noopener\">Boek de snorkel tour</a> om de oudste levende koraal van Amerika te zien![/vc_column_text][vc_custom_heading text=\"Handige informatie voor het snorkelen in Key Largo\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<b>Duur:</b> 2,5 uur<b>\r\nPrijs</b><span style=\"font-weight: 400;\">: Vanaf 64 euro</span><span style=\"font-weight: 400;\">\r\n</span><b>Locatie</b><span style=\"font-weight: 400;\">: 102840 Overseas Hwy</span><span style=\"font-weight: 400;\">\r\n</span><b>Openingstijden:</b> Vaak rond 12.00 en 15.00 uur\r\n<strong>Belangrijk:\u00a0</strong>Alles inbegrepen met uitzondering van de snorkel[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.viator.com%2Fnl-NL%2Ftours%2FKey-Largo%2FSundiver-Snorkel-Tours%2Fd23475-116454P1%3Fpid%3DP00074479%26mcid%3D42383%26medium%3Dlink%26campaign%3Dsnorkelenkeylargo|title:Bestel%20je%20tickets\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"20px\"][/vc_column][vc_column width=\"1/3\"][thb_image retina=\"retina_size\" box_shadow=\"medium-shadow\" thb_border_radius=\"10px\" image=\"14317\"][/thb_image][vc_empty_space height=\"20px\"][vc_column_text][/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Florida\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:12262,12074,12063,9784\"][/vc_column][/vc_row]","post_title":"Snorkelen in Key Largo","post_link":"https://www.heyusa.com/nl/snorkelen-in-key-largo/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Snorkelen Key Largo\" width=\"300\" height=\"209\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/01/snorkel-key-largo-300x209.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Florida Keys","post_tags":"Florida","%_edit_last%":"2","%_edit_lock%":"1685519165:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"168","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style3","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":{"2":{"title":"","post_source_url":""}},"%_yoast_wpseo_focuskw%":"Snorkelen in Key Largo","%_yoast_wpseo_metadesc%":"Bekijk het enige levende rif van Noord Amerika vanuit Key Largo. Met deze excursie ga je snorkelen bij het rif in Key Largo.","%_yoast_wpseo_linkdex%":"69","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"snorkelen \"]","%_wpgmp_location_address%":"Overseas Hwy, Key Largo, FL, Verenigde Staten","%_wpgmp_location_city%":"Key Largo","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.1041194","%_wpgmp_metabox_longitude%":"-80.43066240000002","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"14325","%inline_featured_image%":"0","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1685519236","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Florida Keys","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":14324,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Key Largo","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Key Largo\" width=\"300\" height=\"209\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/01/key-largo-florida-300x209.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Key Largo</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"South Beach, Miami Beach, Florida 33139, Verenigde Staten","location":{"lat":"25.7826123","city":"Miami Beach","state":"Florida","country":"Verenigde Staten","lng":"-80.1340772","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/key-largo/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"25px\"][ultimate_heading main_heading=\"Key Largo\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\" margin_design_tab_text=\"\"][/ultimate_heading][ultimate_heading main_heading=\"Wat te doen in Key Largo\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:35px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_column_text]<strong>Key Largo is het eiland van de Florida Keys dat het dichtst bij Miami ligt. Een ideale combinatie om zowel Miami als de Florida Keys te bezoeken. Het is de plek waar je het enige levende koraalrif ter wereld vindt, een perfecte plek om te duiken. Ook voor andere watersporten zoals snorkelen of kajakken is Key Largo de aangewezen plek. Liever op het vasteland blijven? Ook geen probleem. Zo kun je een bezoek brengen aan het Harry Harris Park, het Dagny Johnson Key Largo Hammock Botanical State Park en liefhebbers van dolfijnen kunnen hun hart ophalen. Alle tips voor een bezoek aan Key Largo.</strong>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1640066907439{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"300px\"][vc_custom_heading text=\"Onderwaterwereld van Key Largo\" font_container=\"tag:div|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Duikhoofdstad van de wereld\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"300px\"][parallax_row opacity=\"90\" enable_mobile=\"parallax-enable-mobile\" image=\"14317\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Key Largo - de duikhoofdstad van de wereld\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]Key Largo is het eerste eiland dat je tegenkomt wanneer je de <a href=\"https://www.heyusa.com/nl/roadtrip-overseas-highay-florida/\">Overseas Highway</a> afrijdt. Het is een populaire vakantiebestemming en de grootste reden daarvoor is de mogelijkheid tot duiken. Het eiland maakt de bijnaam de duikhoofdstad van de wereld ook waar. In het John Pennekamp Coral Reef State Park vind je een waar duikparadijs. Ook op andere manieren kun je de onderwaterwereld bekijken. Vanaf een boot met een glazen bodem kun je het prachtige koraal zien. Je vindt er meer dan 100 soorten tropische vissen.[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][vc_custom_heading text=\"WAT TE DOEN IN KEY LARGO\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_row_inner css=\".vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"9846\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"John Pennekamp Coral Reef State Park\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het John Pennekamp Coral Reef State Park is het eerste onderwaterpark van Amerika. Je ziet er honderden soorten tropische vissen en koraalriffen. In het Key Largo Dry Docks Reef staat een replica van het 6 meter hoog beeld van Christ of the Deep dat in 1961 geschonken werd door de Italiaanse duikondernemer Cressi. Je kunt de plek al duikend bezoeken. Met boten en kajaks kun je naar de riffen om te gaan snorkelen. De boten met een glazen bodem varen vaak verder uit de kust van Key Largo. In 2002 hebben ze een schip van de marine laten zinken voor de kust. Inmiddels is er een plek ontstaan met een prachtige onderwaterwereld.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Key Largo | 102601 Overseas Hwy\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"14320\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Dagny Johnson Key Largo Hammock Botanical State Park\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Dagny Johnson Key Largo Hammock Botanical State Park is een goede plek om beschermde dieren en planten te bekijken. De Amerikaanse krokodil komt bijvoorbeeld voor in het Dagny Johnson Key Largo Hammock Botanical State Park, maar ook katoen en de mahonie maretak. Je kunt het park verkennen op een van de trails die door het park lopen. Met een self guided trail krijg je onderweg allerlei informatie over de dieren en planten die je tegenkomt. Genoeg mogelijkheden voor vogelspotters en fotografen in het Dagny Johnson Key Largo Hammock Botanical State Park.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Key Largo | County Rd 905 &amp; Mile Marker 106\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"14312\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Dolphins Plus\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Ooit al eens willen zwemmen met dolfijnen? Dan raden we je aan het Dolphins Plus te bezoeken op Key Largo. Ze bieden verschillende mogelijkheden aan om te zwemmen met dolfijnen, zo kun je zowel in ondiep als dieper water met de dieren zwemmen. En als je op het droge wilt blijven, kun je dolfijnen aaien of schilderen met dolfijnen.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Key Largo | 101900 Overseas Hwy\"][ult_buttons btn_title=\"Bekijk hier de mogelijkheden\" btn_link=\"url:https%3A%2F%2Fwww.dolphinsplus.com%2F|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][/vc_row_inner][vc_row_inner css=\".vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"14313\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Island Dolphin Care\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Island Dolphin Care is een non profit organisatie die op zoek is naar levensveranderende oplossingen voor gezinnen en kinderen. Mensen met bijvoorbeeld PTTS of autisme kunnen bij Island Dolphin Care terecht voor een behandeling. Al meer dan 20 jaar helpen ze bij Island Dolphin Care vele families, veteranen en andere individuen met hun uitdagingen.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Key Largo | 150 Lorelane Pl\"][ult_buttons btn_title=\"Bekijk hier de mogelijkheden\" btn_link=\"url:https%3A%2F%2Fislanddolphincare.org%2F|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"14315\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Harry Harris Park and Beach\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Op Key Largo vind je het Harry Harris Beach en Park. Een familie-vriendelijke plek aan de Atlantische Oceaan. Het strand wordt beschermd tegen golfslag en eventuele grote vissen door een koraal barri<span class=\"Y2IQFc\" lang=\"nl\">\u00e8</span>re. Hierdoor is het in feite een getijdenpoel geworden waardoor het ideaal is voor kinderen. Bij het water is een uitgestrekt zand waar je een aantal picknicktafels vindt.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Key Largo | 50 E Beach Rd\"][/vc_column_inner][vc_column_inner width=\"1/3\"][/vc_column_inner][/vc_row_inner][vc_row_inner disable_element=\"yes\" css=\".vc_custom_1673517198557{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"12337\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Key West Museum of Art and History\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Key West Museum of Art en History is een plek geworden waar je veel verschillende objecten vindt die de geschiedenis representeren van de Keys. In het oude Custom House dat ooit dienst deed als douanegebouw, postkantoor, rechtbank en later als als gebouw van de Amerikaanse marine, vind je tegenwoordig de Key West Art &amp; Historical Society. Het doel is om de cultuur van de Florida Keys te behouden. Je kunt tentoonstellingen bezoeken die te maken hebben met kunst, architectuur en geschiedenis van de Keys.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Key West | 281 Front Street\"][/vc_column_inner][vc_column_inner width=\"1/3\"][/vc_column_inner][vc_column_inner width=\"1/3\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][thb_blockgrid style=\"style8\" source=\"size:10|post_type:post|by_id:14329,14324,14334\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][thb_postbackground source=\"post_type:post|by_id:9784\"][fullwidth_row content_width=\"100%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1606171128628{padding-top: 75px !important;padding-bottom: 75px !important;}\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"25px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][vc_custom_heading text=\"MEER INSPIRATIE:\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][thb_postgrid style=\"style4\" columns=\"4\" source=\"post_type:post|by_id:12074,12063,9784,8724\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row]","post_title":"Key Largo","post_link":"https://www.heyusa.com/nl/key-largo/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Key Largo\" width=\"300\" height=\"209\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2023/01/key-largo-florida-300x209.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Florida Keys","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1640066907439{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1606171128628{padding-top: 75px !important;padding-bottom: 75px !important;}.vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}.vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}.vc_custom_1673517198557{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1685518427:2","%_edit_last%":"2","%_hide_featured%":null,"%_wpgmp_location_address%":"South Beach, Miami Beach, Florida 33139, Verenigde Staten","%_wpgmp_location_city%":"Miami Beach","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.7826123","%_wpgmp_metabox_longitude%":"-80.1340772","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Key Largo\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%inline_featured_image%":"0","%_yoast_wpseo_primary_category%":"175","%_thumbnail_id%":"14318","%standard-featured-credit%":"","%_yoast_wpseo_focuskw%":"Wat te doen in Key Largo","%_yoast_wpseo_metadesc%":"Wat te doen in Key Largo? Tips voor bezienswaardigheden in Key Largo om niet te missen tijdens je bezoek!","%_yoast_wpseo_linkdex%":"79","%thb-reactions-votes%":"1","%_yoast_wpseo_title%":"Wat te doen in %%title%% %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1685518519","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Florida Keys","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png"},"id":14310,"infowindow_disable":false},{"source":"post","title":"Warner Bros Los Angeles","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Warner Bros\" width=\"300\" height=\"203\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/12/warner-bros-los-angeles-300x203.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Warner Bros Los Angeles</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"Boottocht van 90 minuten over de Hudson en East River","address":"Warner Bros. Studios, Burbank, CA, Verenigde Staten","location":{"lat":"34.1485458","city":"Burbank","state":"California","country":"Verenigde Staten","lng":"-118.3359672","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/warner-bros-los-angeles/","zoom":12,"extra_fields":{"post_excerpt":"Boottocht van 90 minuten over de Hudson en East River","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"30px\"][vc_custom_heading text=\"Warner Bros\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Warner Bros is een van de filmstudio's in Los Angeles die je kunt bezoeken. Talloze films en series zoals <em>Friends</em>, <em>Harry Potter</em> en <em>Gilmore Girls</em> zijn er opgenomen. Bij Warner Bros worden nog dagelijks nieuwe films en series opgenomen. Wil jij eens op een bekende filmset staan en alle ins en outs over Warner Bros horen? Dan kun je de Warner Bros. Studio Tour boeken. Een must voor filmfans![/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf $65 per persoon[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612949537564{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Warner Bros. Studio Tour\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De studio's van Warner Bros liggen in Burbank en zijn het hele jaar toegankelijk. Je kunt het terrein alleen op met een tour omdat er nog bijna dagelijks filmopnames zijn. Met een 2-3 uur durende tour kom je langs verschillende filmsets, ook sets waar op dat moment nog opnames aan de gang zijn. De kans om een bekende acteur of actrices tegen te komen is dus groot! Tijdens de tour kom je langs sets van series als <em>Friends</em> en <em>Gilmore Girls</em>, maar ook van films als <em>Batman</em>, <em>Harry Potte</em>r en <em>Argo</em>. Naast het bezoeken van de sets krijg je ook achtergrondinformatie over het opnemen van de films en series. Een aanrader voor zowel filmfans als voor mensen die meer te weten willen komen over de Hollywood wereld.[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Warner Bros. Studio Tour\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Ontdek de verschillende filmsets\" font_container=\"tag:div|font_size:45|text_align:center\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"14193\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tickets voor Warner Bros. Studio Tour\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Tickets voor de Warner Bros. Studio Tour zijn iets meer dan 65 euro en kun je het beste vooraf <a href=\"https://www.getyourguide.com/warner-bros-studios-hollywood-l21050/los-angeles-warner-bros-studio-tour-hollywood-t55864/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=warnerbrosstudiotekst\" target=\"_blank\" rel=\"noopener\">online</a> al aanschaffen. De tour is populair, dus zorg dat je ruim van te voren kaartjes koopt om het niet te missen.[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fwarner-bros-studios-hollywood-l21050%2Flos-angeles-warner-bros-studio-tour-hollywood-t55864%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dwarnerbrosstudiobanner\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_custom_heading text=\"Overnachten in de buurt van Warner Bros\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Omdat Los Angeles groot is en je veel reistijd vaak kwijt bent, kun je overnachten in de buurt van Warner Bros. Hierdoor ben je direct in de buurt van de studio's. Er zijn <a href=\"https://www.booking.com/searchresults.en.html?city=20011868&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=warnerbrosburbank\" target=\"_blank\" rel=\"noopener\">overnachtingsmogelijkheden genoeg in de buurt van Warner Bros</a>, maar wil je echt om de hoek overnachten? Dan is <a href=\"https://www.booking.com/hotel/us/tangerine.en.html?aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=warnerbrostangerine\" target=\"_blank\" rel=\"noopener\">The Tangerine</a> de beste optie.[/vc_column_text][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>3400 Warner Blvd, Burbank</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Dagelijks meestal tussen 8.30 en 14.30 uur</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Central Perk Cafe\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Sta op de set van Friends\" font_container=\"tag:div|font_size:45|text_align:center\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"14191\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Andere leuke artikelen\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:12865,8343,7708,7537\"][/vc_column][/vc_row]","post_title":"Warner Bros Los Angeles","post_link":"https://www.heyusa.com/nl/warner-bros-los-angeles/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Warner Bros\" width=\"300\" height=\"203\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/12/warner-bros-los-angeles-300x203.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Los Angeles","post_tags":"Californi\u00eb","%_wpb_shortcodes_custom_css%":".vc_custom_1612949537564{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1671703847:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"65","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"14192","%_yoast_wpseo_focuskw%":"Warner Bros","%_yoast_wpseo_title%":"Warner Bros Los Angeles %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een van de filmstudio's die je kunt bezoeken is Warner Bros in Los Angeles. Bezoek Warner Bros met een studio tour en kom op bekende filmsets.","%_yoast_wpseo_linkdex%":"68","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Warner Bros. Studio Tour\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"Warner Bros. Studios, Burbank, CA, Verenigde Staten","%_wpgmp_location_city%":"Burbank","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"34.1485458","%_wpgmp_metabox_longitude%":"-118.3359672","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_primary_category%":"52","%_yoast_indexnow_last_ping%":"1677014875","taxonomy=category":"Bezienswaardigheden Los Angeles","taxonomy=post_tag":"Californi\u00eb","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":14186,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Tickets voor The Edge New York","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The edge\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/12/the-edge-uitzicht-empire-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Tickets voor The Edge New York</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"10 Hudson Yards, New York, NY 10001, Verenigde Staten","location":{"lat":"40.7539515","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-74.0003192","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/the-edge-new-york-city/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Tickets voor het Observation Deck van The Edge New York\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Durf jij New York vanaf een glazen vloer op 335 meter hoogte te bekijken? Bezoek dan The Edge, het hoogste outdoor- uitkijkplatform van New York. In 30 Hudson Yards in de wijk Hudson Yards vind je deze uitkijktoren. Weer een toffe plek om te genieten van de prachtige skyline van New York. Benieuwd naar The Edge? Boek dan snel tickets voor een bezoek aan het <a href=\"https://www.getyourguide.nl/edge-manhattan-l158493/nyc-edge-observation-deck-skip-the-ticket-line-opties-t404016/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=theedgeintrotekst\" target=\"_blank\" rel=\"noopener\">observation deck van The Edge in New York</a>. Daarnaast geven we je alle tips voor een bezoek aan The Edge.[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-arrows-v\"]335 meter hoog[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-building\"]100 verdiepingen[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf \u20ac40 per persoon[/ultimate_icon_list_item][/ultimate_icon_list][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fedge-l158493%2Fnyc-edge-observation-deck-skip-the-ticket-line-options-t404016%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dtheedgeboven|title:Boek%20tickets%20voor%20The%20Edge|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"335 meter hoog\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_empty_space][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Durf jij het aan?\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fedge-l158493%2Fnyc-edge-observation-deck-skip-the-ticket-line-options-t404016%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dtheedgemidden|title:Tickets%20voor%20The%20Edge|target:_blank\" btn_align=\"ubtn-center\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"10255\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Edge New York tickets kopen\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Verschillende soorten tickets voor The Edge\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Voor een bezoek aan The Edge kun je kiezen uit twee verschillende ticket opties. De algemene tickets zijn de goedkoopste, maar leg je al wel direct je bezoek vast. De flex tickets zijn iets duurder, maar dan heb je de flexibiliteit om tijdens je bezoek aan New York zelf het moment te bepalen om The Edge te bezoeken. <a href=\"https://www.getyourguide.nl/edge-manhattan-l158493/nyc-edge-observation-deck-skip-the-ticket-line-opties-t404016/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=theedgebeidetickets\" target=\"_blank\" rel=\"noopener\">Beide tickets</a> kun je het beste online al kopen voordat je naar New York reist.\u00a0</span>[/vc_column_text][vc_custom_heading text=\"Extra optie The Edge\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Voor de echte daredevils is er een extra activiteit toe te voegen aan je bezoek aan The Edge. Je kunt namelijk <a href=\"https://www.viator.com/tours/New-York-City/Edge-Observation-Deck-General-Admission/d687-76823P1?pid=P00074479&amp;mcid=42383&amp;medium=link&amp;campaign=cityclimbtheedge\" target=\"_blank\" rel=\"noopener\">City Climb</a> boeken waarbij je de hoogste openlucht beklimming ter wereld maakt. Je gaat de buitenkant van The Edge beklimmen op meer dan 300 meter hoogte en leunt dan tegen The Edge aan. Iets voor de mensen zonder hoogtevrees in ieder geval.</span>[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fedge-l158493%2Fnyc-edge-observation-deck-skip-the-ticket-line-options-t404016%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dtheedgeonder|title:Tickets%20voor%20The%20Edge|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_custom_heading text=\"Korting op tickets voor The Edge\" font_container=\"tag:h2|font_size:15|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Er zijn mogelijkheden om The Edge te bezoeken met korting. Hiervoor kun je het beste een <a href=\"https://www.heyusa.com/nl/voordeelpassen-new-york/\">voordeelpas van New York</a> aanschaffen. Je hoeft niet een specifieke datum al vast te leggen, maar moet wel een tijdstip reserveren.[/vc_column_text][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie The Edge\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>30 Hudson Yards -vanaf de 4e verdieping in The Shops &amp; Restaurants</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Dagelijks van 10.00 uur tot 22.00 uur</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<strong>Openingstijden kunnen afwijken tijdens Kerst en Oud en Nieuw</strong>[/ultimate_icon_list_item][/ultimate_icon_list][vc_custom_heading text=\"Wat is het beste moment om The Edge te bezoeken?\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">The Edge is 365 dagen per jaar geopend van 10.00 uur \u2018s morgens tot 22.00 uur \u2018s avonds. De laatste lift gaat 50 minuten voor sluiting naar boven.\u00a0</span><span style=\"font-weight: 400;\">\r\n</span><span style=\"font-weight: 400;\">\r\n</span><b>De beste tijden om The Edge te bezoeken:\u00a0</b>\r\n<ul>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Weinig tot geen wachtrijen gedurende de gehele dag</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Een uur voor schemering, je hebt dan dag- en avond in 1x!</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">In het weekend is het er meestal drukker</span></li>\r\n</ul>\r\n[/vc_column_text][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Enjoy the view!\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Uitzicht vanaf The Edge\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"10258\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612946867021{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Over de The Edge in New York\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">Hudson Yards is een van de meest recente bouwprojecten in New York. Een project met woontorens, shopfaciliteiten, restaurants en bezienswaardigheden. Een nieuw uitkijkplatform kan dan natuurlijk niet ontbreken. In 2012 werd ondergronds begonnen met bouwen van 30 Hudson Yards, in 2016 kwamen ze boven de grond. Het observatiedek werd in 2018 toegevoegd en het gebouw werd in 2019 geopend. Sinds 2020 is het ook mogelijk om het observatieplatform van The Edge te bezoeken. In 30 Hudson Yards vind je diverse bedrijven waaronder CNN, Facebook en Warner Media.\u00a0</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"De glazen vloer van The Edge\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Het uitzicht vanaf de 100 verdieping van 30 Hudson Yards is sowieso al de moeite waard om naar boven te gaan. Voor de mensen zonder hoogtevrees is er nog een unieke mogelijkheid: New York bekijken vanaf een glazen platform op 335 meter hoogte. Een dek van 24 meter steekt uit aan de oostelijke kant van het gebouw. Met 347 kilo, 697m2 en 79 glazen panelen is het een unieke manier geworden om New York te bekijken.\u00a0</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Hoogste platform?\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">In New York blijft altijd een strijd gaan omtrent het hoogste gebouw en natuurlijk geldt dit ook voor het hoogste observatieplatform. Officieel is het One World Observatory de hoogste van New York met 386,5 meter, het Empire State Building blijft steken op 373 meter. Toch kan ook The Edge er met een titel vandoor gaan, het is namelijk het hoogste outdoor observatieplatform van New York. De andere twee zijn namelijk binnen.\u00a0</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Hudson Yards\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Als je The Edge gaat bezoeken, breng dan ook direct een bezoek aan Hudson Yards. Je hebt hier vele leuke bezienswaardigheden die de moeite waard zijn. The Vessel is bijvoorbeeld een architectonisch hoogtepuntje die ook nog eens gratis is. Je kunt er winkelen en uit eten bij vele restaurants en mis daarbij Mercado Little Spain niet, de Spaanse food market in Hudson Yards. Vanaf hier kun je ook The High Line opwandelen richting Chelsea en Meatpacking.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1620887540936{background-color: #dadada !important;}\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][ultimate_heading main_heading=\"Veelgestelde vragen over The Edge\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:800;\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][vc_toggle title=\"Wat kost een ticket voor The Edge?\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]Je hebt tickets vanaf 38 euro. The Edge zit bij sommige voordeelpassen inbegrepen.[/vc_toggle][vc_toggle title=\"Hoeveel verdiepingen heeft The Edge?\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]The Edge is gebouwd uit 31 achthoekige torens van 7 verdiepingen. De totale hoogte van The Edge is 335 meter.[/vc_toggle][vc_toggle title=\"Hoe kom ik aan tickets voor The Edge?\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]Je kunt het beste <a href=\"https://www.getyourguide.nl/edge-manhattan-l158493/nyc-edge-observation-deck-skip-the-ticket-line-opties-t404016/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=theedgefaq\" target=\"_blank\" rel=\"noopener\">tickets online kopen</a> voorafgaand aan je bezoek[/vc_toggle][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"80%\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Foto's van The Edge\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][thb_image_slider images=\"10262,10261,10260,10259,10258,10257,10254,10255,10256\"][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York\" font_container=\"tag:div|font_size:50|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:-3408,-1759,1484,-520,1559,10251,10752\"][/vc_column][/vc_row]","post_title":"Tickets voor The Edge New York","post_link":"https://www.heyusa.com/nl/the-edge-new-york-city/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The edge\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/12/the-edge-uitzicht-empire-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden New York","post_tags":"New York","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1612946867021{background-color: #ededed !important;}.vc_custom_1620887540936{background-color: #dadada !important;}","%_edit_last%":"2","%_edit_lock%":"1690379208:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"14","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":[{"title":"Foto credit: Julienne Schaer/NYC & Company","post_source_url":"http://www.nycgo.com"}],"%_thumbnail_id%":"10260","%_yoast_wpseo_focuskw%":"Tickets The Edge","%_yoast_wpseo_title%":"Tickets The Edge New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"The Edge in New York is een van de highlights in New York. Tips voor je bezoek aan de The Edge in New York en Tickets voor The Edge New York","%_yoast_wpseo_linkdex%":"78","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Tickets voor The Edge New York \"]","%_wpgmp_location_address%":"10 Hudson Yards, New York, NY 10001, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7539515","%_wpgmp_metabox_longitude%":"-74.0003192","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1690379336","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_primary_category%":"","%_wp_old_date%":"2021-12-23","taxonomy=category":"Bezienswaardigheden New York","taxonomy=post_tag":"New York","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":10251,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Space Needle Seattle","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Space Needle\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/12/space-needle-seattle-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Space Needle Seattle</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"Boottocht van 90 minuten over de Hudson en East River","address":"400 Broad St, Seattle, WA 98109, Verenigde Staten","location":{"lat":"47.6205063","city":"Seattle","state":"Washington","country":"Verenigde Staten","lng":"-122.3492774","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/space-needle-seattle/","zoom":12,"extra_fields":{"post_excerpt":"Boottocht van 90 minuten over de Hudson en East River","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"30px\"][vc_custom_heading text=\"Space Needle\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De 184 meter hoge Space Needle kenmerkt de skyline van Seattle al sinds 1962. De toren biedt panoramische uitzichten over Seattle en omgeving. Met een lift sta je in 43 seconden op het uitkijkplatform, waar je met geluk Mount Rainier kunt zien liggen. Een must om te bezoeken in Seattle![/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf $35 per persoon[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612949537564{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Toren Space Needle en observatiedek\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het observatiedek van de Space Needle bevindt zich op een hoogte van 159 meter. Op heldere dagen zie je de kust van Seattle en in het binnenland Mount Rainier, Olympic Mountains en Mount Baker. Natuurlijk zijn ook de contouren van de stad goed zichtbaar. Het observatiedek is de gehele dag geopend, hierdoor kun je bijvoorbeeld een combinatie van Seattle bij dag- en nachtlicht zien. De Space Needle werd gebouwd voor de Wereldtentoonstelling van 1962. Je kunt hem ook herkennen uit\u00a0de film <em>Sleepless in Seattle.\u00a0</em>[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Seattle\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Uitzicht van de Space Needle\" font_container=\"tag:div|font_size:45|text_align:center\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"13966\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tickets voor Space Needle\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De Space Needle is een populaire attractie in Seattle. Een ticket voorafgaand aan je bezoek kopen, is zeker aan te raden. Hoewel de lift razendsnel omhoog gaat, kunnen de wachttijden oplopen tot een uur. Neem ruim de tijd voor een bezoek aan de Space Needle.[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fseattle-l198%2Fseattle-space-needle-ticket-t428721%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dspaceneedle\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_custom_heading text=\"SkyCity restaurant\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Boven in de Space Needle bevindt zich het restaurant SkyCity. Het restaurant draait 360 graden rond. Vanwege de populariteit is het raadzaam te reserveren. Wanneer je in het restaurant gaat eten, is een bezoek aan het observatiedek inbegrepen. Online reserveren kan tot 4 personen, 90 dagen van te voren. Ben je met meer personen? Dan moet je telefonisch reserveren.[/vc_column_text][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>400 Broad St, Seattle</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Dagelijks meestal tussen 10.00-20.00 uur, maar de tijden willen nog wel eens verschillen. Check hier de <a href=\"https://www.spaceneedle.com/plan-your-visit\" target=\"_blank\" rel=\"noopener\">openingstijden</a></strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Space Needle\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Icoon in de skyline van Seattle\" font_container=\"tag:div|font_size:45|text_align:center\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"13964\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Andere leuke artikelen\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:4076,2150,8989,4714\"][/vc_column][/vc_row]","post_title":"Space Needle Seattle","post_link":"https://www.heyusa.com/nl/space-needle-seattle/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Space Needle\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/12/space-needle-seattle-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden","post_tags":"Washington","%_wpb_shortcodes_custom_css%":".vc_custom_1612949537564{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1670323733:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"65","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"13965","%_yoast_wpseo_focuskw%":"Space Needle Seattle","%_yoast_wpseo_title%":"Space Needle Seattle %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een van de populairste attracties in Seattle is de Space Needle. Bestel hier je tickets en alle tips voor een bezoek!","%_yoast_wpseo_linkdex%":"77","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Space Needle\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"400 Broad St, Seattle, WA 98109, Verenigde Staten","%_wpgmp_location_city%":"Seattle","%_wpgmp_location_state%":"Washington","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"47.6205063","%_wpgmp_metabox_longitude%":"-122.3492774","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_primary_category%":"65","%_yoast_indexnow_last_ping%":"1677014911","taxonomy=category":"Bezienswaardigheden","taxonomy=post_tag":"Washington","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":13961,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"ModernHaus SoHo","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"In het bijzondere ModernHaus hotel in SoHo overnacht je als een celebrity.\" width=\"300\" height=\"206\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/11/modernhaus-soho-hotel-300x206.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">ModernHaus SoHo</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"In dit #cool hotel overnacht je als een filmster. Alsof je op de set van Sex & The City bent. ","address":"27 Grand St, New York, NY 10013, Verenigde Staten","location":{"lat":"40.7227012","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-74.0047637","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/hotels/overnachten-in-new-york-city/modernhaus-soho/","zoom":12,"extra_fields":{"post_excerpt":"In dit #cool hotel overnacht je als een filmster. Alsof je op de set van Sex & The City bent. ","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"#cool hotel in SoHo\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][ultimate_heading main_heading=\"27 Grand Street, SoHo, Manhattan\" heading_tag=\"div\" main_heading_font_family=\"font_family:Oswald|font_call:Oswald\" main_heading_font_size=\"desktop:30px;\" main_heading_line_height=\"desktop:35px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"ModernHaus in SoHo\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][ultimate_heading main_heading=\"$$$\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]ModernHaus SoHo is zo'n typisch hotel wat je op televisie ziet. Bijvoorbeeld in Sex and The City, Gossip Girl of The Real Housewives of New York. Glitter, glamour \u00e9n heel fancy. Oprecht een #cool hotel in \u00e9\u00e9n van de hipste wijken van Manhattan. Er is bijvoorbeeld een rooftop m\u00e9t zwembad, een rooftop cocktailbar en twee chique restaurants. De kamers zijn ruim en modern ingericht met geweldige views. Dit is een celebrity hotel, een hotel waar je gezien wilt worden met een 'touch of glamour'.[/vc_column_text][ultimate_heading main_heading=\"Geselecteerd door Hey!USA\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]ModernHaus SoHo is door Hey!USA geselecteerd omdat dit hotel h\u00e9t ultieme New York uitstraalt. Het New York van op televisie en in de film. Glitter, glamour \u00e9n Hollywood. Je kunt je met gemak voorstellen dat Kim Kardashian hier komt logeren. Toegegeven, het hotel is dan ook niet bepaald budgetvriendelijk, maar hoort absoluut thuis op je #bucketlist.[/vc_column_text][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fmodernhaus-soho.nl.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dheyusa-hotelcollection-hotelpagina|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"13926,13935,13930,13931,13932,13933,13934,13936,13937,13938\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"13937\" img_size=\"large\" add_caption=\"yes\" style=\"vc_box_shadow_3d\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]De wijk SoHo is \u00e9\u00e9n van de hipste van New York. In de buurt kun je geweldig shoppen, er zijn talloze hotspots, cocktailbars en om de hoek begint Chinatown.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Toplocatie in SoHo\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"Gratis WiFi\"][thb_iconlist icon=\"fas fa-glass-cheers\" list_content=\"Bar\"][thb_iconlist icon=\"fas fa-binoculars\" list_content=\"Rooftop\"][thb_iconlist icon=\"fas fa-swimming-pool\" list_content=\"Zwembad\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Comfortabele bedden\"][thb_iconlist icon=\"fas fa-running\" list_content=\"Gym\"][thb_iconlist icon=\"fas fa-utensils\" list_content=\"Restaurants\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fmodernhaus-soho.nl.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dheyusa-hotelcollection-hotelpagina|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Andere hotels in New York City:\" main_heading_color=\"#b34a4c\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"25px\"][thb_postgrid style=\"style4\" columns=\"4\" source=\"size:8|post_type:post|categories:109\"][/vc_column][/vc_row]","post_title":"ModernHaus SoHo","post_link":"https://www.heyusa.com/nl/hotels/overnachten-in-new-york-city/modernhaus-soho/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"In het bijzondere ModernHaus hotel in SoHo overnacht je als een celebrity.\" width=\"300\" height=\"206\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/11/modernhaus-soho-hotel-300x206.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Overnachten in New York City","post_tags":"","%inline_featured_image%":"0","%_edit_lock%":"1681201690:1","%_edit_last%":"1","%_yoast_wpseo_primary_category%":"109","%_thumbnail_id%":"13926","%_hide_featured%":null,"%_wpgmp_location_address%":"27 Grand St, New York, NY 10013, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7227012","%_wpgmp_metabox_longitude%":"-74.0047637","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"13\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%post-primary-category%":"auto","%featured_image_override%":"off","%standard-featured-credit%":"Nikolas Koenig - ModernHaus SoHo","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_focuskw%":"made hotel","%_yoast_wpseo_metadesc%":"Dit #wow hotel straalt glitter en glamour uit. ModernHaus SoHo is een hotel \u00e0 la Sex and The City. Een bijzonder hotel met allure.","%_yoast_wpseo_linkdex%":"41","%post_source%":[{"title":"ModernHaus SoHo","post_source_url":"https://www.modernhaushotel.com"}],"%_yoast_indexnow_last_ping%":"1677014916","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%executive_summary%":"Slapen als een celebrity ","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Overnachten in New York City","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png"},"id":13925,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png","name":"Hotels","id":"13","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Penny Hotel","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Penny is het nieuwste hotel in Williamsburg, Brooklyn\" width=\"300\" height=\"225\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/11/the-penny-hotel-williamsburg-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Penny Hotel</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"In dit #cool hotel in Williamsburg, logeer je tussen kunst. The Penny is het nieuwste hotel van deze hippe wijk in Brooklyn.","address":"288 N 8th St, Brooklyn, NY 11211, Verenigde Staten","location":{"lat":"40.7155065","state":"New York","country":"Verenigde Staten","lng":"-73.95272419999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/overnachten-in-new-york-city/penny-hotel/","zoom":12,"extra_fields":{"post_excerpt":"In dit #cool hotel in Williamsburg, logeer je tussen kunst. The Penny is het nieuwste hotel van deze hippe wijk in Brooklyn.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"#cool art-hotel in Williamsburg\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][ultimate_heading main_heading=\"288 North 8th Street, Williamsburg, Brooklyn\" heading_tag=\"div\" main_heading_font_family=\"font_family:Oswald|font_call:Oswald\" main_heading_font_size=\"desktop:30px;\" main_heading_line_height=\"desktop:35px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"The Penny Williamsburg\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"$$$\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]<a href=\"https://www.heyusa.com/nl/new-york/williamsburg/\" target=\"_blank\" rel=\"noopener\">Williamsburg</a> heeft al verschillende hippe hotels. Zoals The Wythe, The William Vale en het Williamsburg Hotel. De 'new girl in town' heet 'Penny'. Een nieuw, hip kunsthotel in de eveneens hippe wijk Williamsburg. The Penny valt op vanwege z'n vele kunst. Overal waar je kijkt, hangen tekeningen en kunstwerken. Het hotel werd ontwikkeld door dezelfde mensen achter de populaire 'Freehand' hotels. De kamers zijn ruim, hebben een fijne uitstraling \u00e9n meestal een kleine kitchenette. Je kunt gratis koffie drinken op de kamer, maar ook in de lobby. Je kunt fietsen huren om te touren door <a href=\"https://www.heyusa.com/nl/newyork/brooklyn/\" target=\"_blank\" rel=\"noopener\">Brooklyn</a> \u00e9n elke kamer beschikt over gefilterd drinkwater.[/vc_column_text][ultimate_heading main_heading=\"Geselecteerd door Hey!USA\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]The Penny is door Hey!USA geselecteerd omdat dit hotel een verrijking is van het hippe Williamsburg \u00e9n daardoor meer keuze biedt. Het heeft een #coole vibe, er is veel kunst \u00e9n ook qua ligging ideaal. Twee metrohaltes liggen op slechts een paar minuutjes wandelen. Het centrum van Williamsburg, Bedford Street, ligt eveneens dichtbij.[/vc_column_text][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fthe-penny-williamsburg-brooklyn.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dhotel-pagina-heyusa-hotelcollection|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"13919,13920,13921,13913,13922\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"13922\" img_size=\"large\" add_caption=\"yes\" style=\"vc_box_shadow_3d\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Rondom The Penny zijn talloze hotspots te vinden. Van hippe ontbijt plekjes tot restaurants, koffiebars \u00e9n McCarren Park. Zowel metrolijn L als G liggen om de hoek, waardoor je \u00f3\u00f3k supersnel in Manhattan bent.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"In het hippe Williamsburg\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"Gratis WiFi\"][thb_iconlist icon=\"fas fa-coffee\" list_content=\"Gratis koffie\"][thb_iconlist icon=\"fas fa-glass-cheers\" list_content=\"Bar\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Comfortabele bedden\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fthe-penny-williamsburg-brooklyn.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dhotel-pagina-heyusa-hotelcollection|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Andere hotels in New York City:\" main_heading_color=\"#b34a4c\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"25px\"][thb_postgrid style=\"style4\" columns=\"4\" source=\"size:8|post_type:post|categories:109\"][/vc_column][/vc_row]","post_title":"Penny Hotel","post_link":"https://www.heyusa.com/nl/overnachten-in-new-york-city/penny-hotel/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Penny is het nieuwste hotel in Williamsburg, Brooklyn\" width=\"300\" height=\"225\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/11/the-penny-hotel-williamsburg-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Overnachten in New York City","post_tags":"","%inline_featured_image%":"0","%_edit_lock%":"1669740481:1","%_edit_last%":"1","%_yoast_wpseo_primary_category%":"109","%_thumbnail_id%":"13913","%_hide_featured%":null,"%_wpgmp_location_address%":"288 N 8th St, Brooklyn, NY 11211, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7155065","%_wpgmp_metabox_longitude%":"-73.95272419999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"13\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%post-primary-category%":"auto","%featured_image_override%":"off","%standard-featured-credit%":"The Penny","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_focuskw%":"made hotel","%_yoast_wpseo_metadesc%":"The Penny is het nieuwste hotel van het hippe Williamsburg in Brooklyn. In dit #cool hotel logeer je tussen kunst. Veel kunst. Een fijn hotel in Brooklyn.","%_yoast_wpseo_linkdex%":"40","%post_source%":[{"title":"The Penny","post_source_url":"https://www.penny-hotel.com"}],"%_yoast_indexnow_last_ping%":"1677014918","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%executive_summary%":"Kunsthotel in Williamsburg","taxonomy=category":"Overnachten in New York City","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png"},"id":13912,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png","name":"Hotels","id":"13","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Riu Plaza Times Square","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Het RIU Plaza Times Square in New York City is een populair hotel bij Nederlanders en Belgen\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/11/riu-plaza-times-square-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Riu Plaza Times Square</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"Dit betaalbare #cool hotel in Hell's Kitchen heeft een toffe boutique-sfeer. Het hotel is populair bij Nederlandse en Belgische reizigers.","address":"305 W 46th St, New York, NY 10036, Verenigde Staten","location":{"lat":"40.7601952","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.98813419999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/overnachten-in-new-york-city/riu-plaza-times-square/","zoom":12,"extra_fields":{"post_excerpt":"Dit betaalbare #cool hotel in Hell's Kitchen heeft een toffe boutique-sfeer. Het hotel is populair bij Nederlandse en Belgische reizigers.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"#cool &amp; betaalbaar hotel in Hell's Kitchen\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][ultimate_heading main_heading=\"305 West 46th Street, Manhattan, New York City\" heading_tag=\"div\" main_heading_font_family=\"font_family:Oswald|font_call:Oswald\" main_heading_font_size=\"desktop:30px;\" main_heading_line_height=\"desktop:35px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Hotel Riu Plaza New York Times Square\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"$$$\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Dit #cool en betaalbaar hotel in Hell's Kitchen in Manhattan, New York City is <em>'the place to be'</em>\u00a0van veel Nederlanders en Belgen. Vanwege de ideale ligging en de perfecte prijs/kwaliteit verhouding, is dit een zeer populair hotel om te verblijven in New York. Ondanks dat het een groot hotel is, er zijn 647 kamers, voelt het als een boutique hotel met een glamoureus uitstraling. De kamers zijn voor New Yorkse begrippen ruim, aangekleed in een 'fashion'-stijl \u00e9n met geweldig uitzicht. Als je tenminste op de bovenste etages zit (vraag daar dus naar bij de boeking). Het hotel heeft veel faciliteiten, zoals een gym, verschillende bars, vergaderzalen en een uitgebreid Amerikaans ontbijtbuffet.[/vc_column_text][ultimate_heading main_heading=\"Geselecteerd door Hey!USA\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]RIU Plaza Times Square is door Hey!USA geselecteerd omdat dit hotel bewezen populair is bij reizigers uit Nederland en Belgen. Het heeft een chique, boutique uitstraling maar alle faciliteiten die je van een groot hotel verwacht. Het is \u00f3\u00f3k een ideaal hotel voor een zakenreis. Door de ligging in Hell's Kitchen, vlak achter Times Square, ben je midden in het bruisende Midtown. Er zijn verschillende metrohaltes in de buurt, theaters, restaurants en gezellige bars.[/vc_column_text][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Friu-plaza-new-york-times-square.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dhotel-page-heyusa-hotelcollection|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"13893,13895,13896,13897,13902,13898,13899,13901,13900\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"13899\" img_size=\"large\" add_caption=\"yes\" style=\"vc_box_shadow_3d\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]RIU Plaza Times Square ligt in het bruisende Hell's Kitchen. Een paradijs voor foodies, want overal waar je kijkt zijn restaurants te vinden, uit alle windhoeken van de wereld. Het hotel ligt ideaal, nabij Times Square, het Theaterdistrict, verschillende metrohaltes, 42nd Street en Bryant Park.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Toplocatie\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"Gratis WiFi\"][thb_iconlist icon=\"fas fa-utensils\" list_content=\"Restaurant\"][thb_iconlist icon=\"fas fa-glass-cheers\" list_content=\"Bar\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Comfortabele bedden\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Friu-plaza-new-york-times-square.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dhotel-page-heyusa-hotelcollection|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Andere hotels in New York City:\" main_heading_color=\"#b34a4c\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"25px\"][thb_postgrid style=\"style4\" columns=\"4\" source=\"size:8|post_type:post|categories:109\"][/vc_column][/vc_row]","post_title":"Riu Plaza Times Square","post_link":"https://www.heyusa.com/nl/overnachten-in-new-york-city/riu-plaza-times-square/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Het RIU Plaza Times Square in New York City is een populair hotel bij Nederlanders en Belgen\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/11/riu-plaza-times-square-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Overnachten in New York City","post_tags":"","%inline_featured_image%":"0","%_edit_lock%":"1669739170:1","%_edit_last%":"1","%_yoast_wpseo_primary_category%":"109","%_thumbnail_id%":"13893","%_hide_featured%":null,"%_wpgmp_location_address%":"305 W 46th St, New York, NY 10036, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7601952","%_wpgmp_metabox_longitude%":"-73.98813419999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"13\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%post-primary-category%":"auto","%featured_image_override%":"off","%standard-featured-credit%":"RIU Plaza","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_focuskw%":"made hotel","%_yoast_wpseo_metadesc%":"RIU Plaza Times Square is een populair hotel bij reizigers uit Nederland en Belgi\u00eb. Perfecte ligging, een boutique uitstraling \u00e9n betaalbaar!","%_yoast_wpseo_linkdex%":"51","%post_source%":[{"title":"RIU Plaza","post_source_url":"https://www.riu.com"}],"%_yoast_indexnow_last_ping%":"1677014920","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%executive_summary%":"Populair bij reizigers uit Nederland en Belgi\u00eb","taxonomy=category":"Overnachten in New York City","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png"},"id":13891,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png","name":"Hotels","id":"13","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Container Park Las Vegas","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Container Park\" width=\"300\" height=\"197\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/11/container-park-las-vegas-300x197.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Container Park Las Vegas</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"707 E Fremont St, Las Vegas, NV 89101, Verenigde Staten","location":{"lat":"36.1675601","city":"Las Vegas","state":"Nevada","country":"Verenigde Staten","lng":"-115.1384837","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/container-park-las-vegas/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"25px\"][vc_custom_heading text=\"Container Park Las Vegas\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<div class=\"page\" title=\"Page 1\">\r\n<div class=\"section\">\r\n<div class=\"layoutArea\">\r\n<div class=\"column\">\r\n\r\nIn 2103 werd in Las Vegas Container Park geopend. Een outdoor concept waar je kunt shoppen, uit eten kunt gaan en verschillende soorten entertainment. In op elkaar gestapelde zeecontainers vind je leuke boetiekjes en eetstalletjes. Ook voor gezinnen met kinderen is Container Park een leuke plek om te bezoeken, je vindt er verschillende speelmogelijkheden en kind-vriendelijke restaurants.\r\n\r\n</div>\r\n</div>\r\n</div>\r\n</div>\r\n<span style=\"font-weight: 400;\">\u00a0</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Gratis[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612950540814{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Tips voor Container Park\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<div class=\"page\" title=\"Page 1\">\r\n<div class=\"section\">\r\n<div class=\"layoutArea\">\r\n<div class=\"column\">\r\n<p style=\"text-align: center;\">Container Park ligt een paar straten verwijderd van <a href=\"https://www.heyusa.com/nl/fremont-street-las-vegas/\">Fremont Street</a>. Bij de ingang word je verwelkomd door een beeld van een gigantische vuurspuwende bidsprinkhaan. Binnen in Container Park vind je een scala aan unieke winkels. Ook de verscheidenheid aan eetgelegenheden is een reden om naar Container Park af te reizen. Het is een leuke plek om cocktails te drinken bij verschillende bars onder het genot van entertainment. Gedurende het jaar zijn er diverse concerten of andere evenementen.</p>\r\n\r\n</div>\r\n</div>\r\n</div>\r\n</div>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Praying Mantis\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"De vuurspuwende bidsprinkhaan\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"13754\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Wat te doen in Container Park\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<div class=\"page\" title=\"Page 1\">\r\n<div class=\"section\">\r\n<div class=\"layoutArea\">\r\n<div class=\"column\">\r\n\r\nContainer Park is een leuke mix aan activiteiten, shoppen en eten en drinken. Vermaken doe je je bij een van de vele bars of winkels, maar daarnaast kun je ook terecht bij <strong>The House of 1000 Pins</strong>. Hier kun je pins bekijken die gemaakt zijn door lokale artiesten. Natuurlijk kan een speciale Downtown Container Park pin niet ontbreken.\r\n\r\nBij de ingang vind je een beeld van een vuurspuwende bidsprinkhaan die direct de aandacht trekt: <strong>Praying Mantis</strong>. Gedurende het jaar worden verschillende <strong>events</strong> georganiseerd in Container Park. Rondom kerst komt Santa Clause langs, er zijn Magic Shows en evenementen met muziek. Je kunt Container Park <a href=\"https://www.getyourguide.com/las-vegas-l58/las-vegas-2-hour-guided-segway-tour-t178371/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=containerparksegwaytour\" target=\"_blank\" rel=\"noopener\">verkennen per segway</a> en daarbij kom je alles te weten over deze leuke plek in Downtown Las Vegas.\r\n\r\n</div>\r\n</div>\r\n</div>\r\n</div>\r\n<span style=\"font-weight: 400;\">\u00a0</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Shoppen in Container Park\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<div class=\"page\" title=\"Page 1\">\r\n<div class=\"section\">\r\n<div class=\"layoutArea\">\r\n<div class=\"column\">\r\n\r\nIn Container Park vind je een selectie van unieke winkels. Hieronder enkele voorbeelden:\r\n<ul>\r\n \t<li>The Alchemist Cabinet \u2013 thee</li>\r\n \t<li>Sugar Shop Candy and gifts \u2013 snoep</li>\r\n \t<li>Art Box \u2013 lokaal gemaakte kleding</li>\r\n \t<li>DTLV Merch \u2013 merchandise Downtown Las Vegas Gift Envy \u2013 lokale souvenirs</li>\r\n \t<li>Olive Branch \u2013 olijfolie</li>\r\n \t<li>Las Vegas Chocolate Bar \u2013 chocolade</li>\r\n</ul>\r\n</div>\r\n</div>\r\n</div>\r\n</div>\r\n<span style=\"font-weight: 400;\">\u00a0</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Restaurants Container Park\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<div class=\"page\" title=\"Page 1\">\r\n<div class=\"section\">\r\n<div class=\"layoutArea\">\r\n<div class=\"column\">\r\n\r\nCombineer shoppen met de gezelligheid die er hangt bij de restaurants in Container Park. Een paar leuke voorbeelden van restaurants om een drankje te gaan doen of iets te eten zijn:\r\n<ul>\r\n \t<li>Waffelato \u2013 Hong Kong waffles</li>\r\n \t<li>Oak &amp; Ivy \u2013 Cocktail bar</li>\r\n \t<li>Mob Pie \u2013 Pizza</li>\r\n \t<li>Pinches Tacos \u2013 Mexicaans Downtown Terrace \u2013 Gourmet service</li>\r\n</ul>\r\n</div>\r\n</div>\r\n</div>\r\n</div>\r\n<span style=\"font-weight: 400;\">\u00a0</span>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Container Park\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_custom_heading text=\"Leuke mix aan winkels, eetgelegenheden en entertainment\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:3\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"13752\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Las Vegas\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:13191,12584,11542,11382\"][/vc_column][/vc_row]","post_title":"Container Park Las Vegas","post_link":"https://www.heyusa.com/nl/container-park-las-vegas/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Container Park\" width=\"300\" height=\"197\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/11/container-park-las-vegas-300x197.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Las Vegas","post_tags":"Nevada","%_wpb_shortcodes_custom_css%":".vc_custom_1612950540814{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1669213922:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"54","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"13753","%_yoast_wpseo_focuskw%":"Container Park Las Vegas","%_yoast_wpseo_metadesc%":"Container Park in Las Vegas is een leuke plek met winkels, restaurants en vele events. Tips voor een bezoek aan Container Park","%_yoast_wpseo_linkdex%":"78","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"707 E Fremont St, Las Vegas, NV 89101, Verenigde Staten","%_wpgmp_location_city%":"Las Vegas","%_wpgmp_location_state%":"Nevada","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"36.1675601","%_wpgmp_metabox_longitude%":"-115.1384837","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_primary_category%":"54","%_yoast_indexnow_last_ping%":"1677014921","taxonomy=category":"Bezienswaardigheden Las Vegas","taxonomy=post_tag":"Nevada","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":13761,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"The Civilian","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Civilian Hotel in Hell&#039;s Kitchen New York City\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/11/the-civilian-queen-room-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">The Civilian</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"Dit #cool hotel in Hell\u2019s Kitchen in Manhattan, New York City is \u2018the place to be\u2019 als je fan bent van musicals en Broadway.","address":"305 W 48th St, New York, NY 10036, Verenigde Staten","location":{"lat":"40.76143","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.9874509","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/overnachten-in-new-york-city/the-civilian/","zoom":12,"extra_fields":{"post_excerpt":"Dit #cool hotel in Hell\u2019s Kitchen in Manhattan, New York City is \u2018the place to be\u2019 als je fan bent van musicals en Broadway.","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"#cool hotel in Hell's Kitchen\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][ultimate_heading main_heading=\"305 West 48th Street, Manhattan, New York City\" heading_tag=\"div\" main_heading_font_family=\"font_family:Oswald|font_call:Oswald\" main_heading_font_size=\"desktop:30px;\" main_heading_line_height=\"desktop:35px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"The Civilian Hotel\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"$$$$\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Dit #cool hotel in Hell's Kitchen in Manhattan, New York City is <em>'the place to be'</em> als je fan bent van musicals en <a href=\"https://www.heyusa.com/nl/broadway-new-york/\">Broadway</a>. Het hele hotel ademt Broadway. Overal waar je kijkt zie je prachtige foto's van Broadway musicals van toen en nu. De glitter en glamour van Broadway is met een vintage-touch verwerkt in het interieur van het hotel en de kamers. Meest bijzonder in The Civilian is toch de 'Blue Room'. Deze ruimte in de bar van het hotel is volledig gevuld met vitrinekasten met Broadway memorabilia van The Phantom of the Opera, Wicked en Kinky Boots.[/vc_column_text][ultimate_heading main_heading=\"Geselecteerd door Hey!USA\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]The Civilian is door Hey!USA geselecteerd omdat dit hotel \u00e9\u00e9n grote ode aan Broadway is. Hierdoor is The Civilian onderscheidend en een bijzonder hotel, met een thema dat we nog niet eerder in New York tegenkwamen. Dit boutique hotel is tot in de puntjes gestyled, heeft een vintage / glamour vibe \u00e9n een rooftopbar.[/vc_column_text][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fcivilian-nyc.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dcivilian-hotel-page-heyusa-website|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"13769,13774,13772,13775,13776\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"13772\" img_size=\"large\" add_caption=\"yes\" style=\"vc_box_shadow_3d\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]The Civilian Hotel ligt midden in het bruisende Hell's Kitchen. D\u00e9 plek voor foodies met talloze restaurants. Times Square is slechts twee straten verwijderd en de grote Broadway theaters liggen op wandelafstand.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Toplocatie\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"Gratis WiFi\"][thb_iconlist icon=\"fas fa-utensils\" list_content=\"Restaurant\"][thb_iconlist icon=\"fas fa-glass-cheers\" list_content=\"Bar\"][thb_iconlist icon=\"fas fa-binoculars\" list_content=\"Rooftopbar\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Comfortabele bedden\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fcivilian-nyc.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dcivilian-hotel-page-heyusa-website|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Andere hotels in New York City:\" main_heading_color=\"#b34a4c\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"25px\"][thb_postgrid style=\"style4\" columns=\"4\" source=\"size:8|post_type:post|categories:109\"][/vc_column][/vc_row]","post_title":"The Civilian","post_link":"https://www.heyusa.com/nl/overnachten-in-new-york-city/the-civilian/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Civilian Hotel in Hell&#039;s Kitchen New York City\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/11/the-civilian-queen-room-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Overnachten in New York City","post_tags":"","%inline_featured_image%":"0","%_edit_lock%":"1669734635:1","%_edit_last%":"1","%_yoast_wpseo_primary_category%":"109","%_thumbnail_id%":"13769","%_hide_featured%":null,"%_wpgmp_location_address%":"305 W 48th St, New York, NY 10036, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.76143","%_wpgmp_metabox_longitude%":"-73.9874509","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"13\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%post-primary-category%":"auto","%featured_image_override%":"off","%standard-featured-credit%":"The Civilian, Johnny Miller. ","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_focuskw%":"made hotel","%_yoast_wpseo_metadesc%":"Dit #cool hotel in Hell's Kitchen is 'the place to be' voor Broadway-fans. Overal waar je kijkt zie je foto's en memorabilia uit musicals!","%_yoast_wpseo_linkdex%":"46","%post_source%":[{"title":"Fotografie: The Civilian","post_source_url":"https://www.civilianhotel.com"}],"%_yoast_indexnow_last_ping%":"1677014925","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%executive_summary%":"#cool Broadway hotel in Hell's Kitchen","taxonomy=category":"Overnachten in New York City","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png"},"id":13768,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png","name":"Hotels","id":"13","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Kerst in New York","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Kerst in New York bij het Rockefeller Center\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/11/rockefeller-center-kerst--300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Kerst in New York</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"Boottocht van 90 minuten over de Hudson en East River","address":"808 Eagle Point Rd, Peach Springs, AZ 86434, Verenigde Staten","location":{"lat":"36.011943","city":"Peach Springs","state":"Arizona","country":"Verenigde Staten","lng":"-113.8108372","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/kerst-in-new-york/","zoom":12,"extra_fields":{"post_excerpt":"Boottocht van 90 minuten over de Hudson en East River","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"30px\"][vc_custom_heading text=\"Ontdek de kerstsfeer in New York\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In december naar Amerika, een unieke periode om het land te bezoeken. Want <a href=\"https://www.heyusa.com/nl/kerst-in-amerika/\">kerst in Amerika</a> dat is een ervaring op zich. Een van de beste steden waar je de kerstsfeer goed kunt ervaren is New York. Wat dacht je van de versieringen in de stad, alle lichtjes, overal kerstmarkten, schaatsbanen en of de ultieme kerstervaring in de wijk <a href=\"https://www.heyusa.com/nl/kerst-dyker-heights-brooklyn/\">Dyker Heights</a>. Als er een plek is om in de kerststemming te komen, dan is het New York wel. Een magische ervaring en een heel spektakel. Kerst is bij de Amerikanen een belangrijke feestdag, dus alles wordt uit de kast gehaald. Ga jij in de kerstperiode naar New York? Lees dan snel verder zodat je alles weet over kerst in New York![/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1698998329302{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"550px\"][vc_custom_heading text=\"Kerstversiering op de grote warenhuizen\" font_container=\"tag:div|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"De gevels van Saks Fifth Avenue\" font_size=\"60\" line_height=\"60\" font_color=\"#ffffff\"][vc_empty_space height=\"550px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"20018\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" thb_row_padding=\"true\" thb_column_padding=\"true\" content_placement=\"middle\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][thb_image retina=\"retina_size\" full_width=\"true\" image=\"13675\"][/thb_image][/vc_column][vc_column width=\"1/2\"][vc_row_inner][vc_column_inner width=\"5/6\"][heyusa_heading tag=\"div\" heading=\"Geniet van de kerstsfeer\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][vc_custom_heading text=\"Kerstmarkten in New York\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Er zijn in New York verschillende kerstmarkten om te bezoeken. Vanaf eind oktober staan de eerste kerstmarkten al in New York. Hier kun je gezellige kerstcadeautjes en kerstversieringen kopen, er is eten en drinken, kortom een leuke kerstsfeer! <a href=\"https://www.heyusa.com/nl/bryant-park-new-york-city/\">Bryant Park</a> heeft de grootste kerstmarkt van New York, hier kun je \u00f3\u00f3k schaatsen.\r\nLocaties met kerstmarkten in New York:\r\n<ul>\r\n \t<li>Columbus Circle Holiday Market</li>\r\n \t<li>Union Square Market</li>\r\n \t<li>Bryant Park</li>\r\n \t<li>Grand Central Holiday Fair</li>\r\n \t<li>Grand Holiday Bazaar</li>\r\n \t<li>The Market at Westfield World Trade Center</li>\r\n \t<li>Christmas Market at Amaze Light Festival</li>\r\n</ul>\r\n[/vc_column_text][ult_buttons btn_title=\"Mee op een tour langs alle kerstmarkten? Boek hier je tickets!\" btn_link=\"url:https%3A%2F%2Fwww.viator.com%2Ftours%2FNew-York-City%2FNew-York-City-Holiday-Lights-and-Markets-Walking-Tour%2Fd687-5637P8%3Fpid%3DP00074479%26mcid%3D42383%26medium%3Dlink%26campaign%3Dkerstinnewyorkkerstmarktentour\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" thb_row_padding=\"true\" thb_column_padding=\"true\" content_placement=\"middle\"][vc_column width=\"1/2\"][vc_row_inner][vc_column_inner width=\"5/6\"][heyusa_heading tag=\"div\" heading=\"Bind de schaatsen onder!\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][vc_custom_heading text=\"Schaatsbanen in New York\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Vanaf eind oktober is het weer mogelijk om de schaatsen onder te binden in New York. Op prachtige en iconische locaties kun je schaatsen in New York. De bekendste locaties zijn <strong>Rockefeller Center</strong> en <strong>Central Park</strong>. Maar er zijn nog meer plekken om te schaatsen in New York. Ook bij kerstmarkt in <strong>Bryant Park</strong>, kun je rondjes maken. Hier kun je gratis schaatsen, maar maak je wel de kosten voor de huur van schaatsen. Bij de schaatsbanen bij <a href=\"https://www.heyusa.com/nl/central-park-new-york-city/\">Central Park</a> en <a href=\"https://www.heyusa.com/nl/new-york/top-of-the-rock/\">Rockefeller</a> die je entree te betalen naast de schaatshuur.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][thb_image retina=\"retina_size\" full_width=\"true\" image=\"13673\"][/thb_image][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" disable_element=\"yes\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1698754868953{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Kerstmarkten in New York\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Een en al gezelligheid\" font_container=\"tag:div|font_size:45|text_align:center\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"13675\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" disable_element=\"yes\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1698754990167{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Bind de schaatsen onder\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Op een van de vele schaatsbanen in New York\" font_container=\"tag:div|font_size:45|text_align:center\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"13673\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1698998683520{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"550px\"][vc_custom_heading text=\"Kerstversieringen in New York\" font_container=\"tag:div|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ontdek de mooiste versieringen in de stad\" font_size=\"60\" line_height=\"60\" font_color=\"#ffffff\"][vc_empty_space height=\"550px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"20019\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Meer kerst in New York!\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Dit zijn onze tips om de kerstsfeer te proeven\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][vc_empty_space height=\"50px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"13676\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Waar vind je de mooiste kerstversieringen in New York?\" font_container=\"tag:h3|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"10px\"][vc_column_text]Wandel door New York en je kunt niet om de kerstverlichting heen in de stad. Je komt direct in de kerststemming met alle prachtige versieringen. De straten zijn versierd, net als de etalages van grote warenhuizen als Bloomingdales, Bergdorf Goodman, Saks Fifth Avenue en Macy's. Macy's staat bekend om de vele versieringen, zowel aan de buitenkant als in de winkel (ook een heus Santaland!). Vaak worden de versieringen eind november opgehangen, na Thanksgiving.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"13678\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"De mooiste kerstbomen in New York\" font_container=\"tag:h3|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"10px\"][vc_column_text]De beroemdste kerstboom van New York staat bij het Rockefeller Center. Het is ieder jaar een heel spektakel waar mensen zelfs aan de tv gekluisterd zitten. Het ontsteken van de lichtjes is een traditie dat al sinds 1931 gebeurd. In de boom vind je meer van 50.000 LED lampjes. Andere plekken in New York waar reusachtige kerstbomen geplaatst worden zijn: Madison Square Park, Bryant Park, Wall Street,\u00a0 New York Public Library, Central Park, Radio City Music Hall en Washington Square Park.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"9685\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Bezoek verschillende kerstactiviteiten in New York\" font_container=\"tag:h3|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"10px\"][vc_column_text]Naast alle versieringen, kerstmarkten, kerstbomen en schaatsbanen zijn er tal van specifieke kerstactiviteiten die je kunt ondernemen in New York in deze periode. Zo kun je de beroemde voorstelling van de <a href=\"https://www.getyourguide.nl/new-york-l59/new-york-city-radio-city-kerst-spectaculair-t406291/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=kerstinnycrockettesintekst\" target=\"_blank\" rel=\"noopener\"><strong>Rockettes</strong></a> aanschouwen in Radio City Music Hall, maar ook naar de meest versierde wijk van New York (<a href=\"https://www.heyusa.com/nl/kerst-dyker-heights-brooklyn/\"><strong>Dyker Heights</strong></a>) afreizen. Beiden zijn aanraders om de kerstsfeer te proeven in New York. Ook de <a href=\"https://www.getyourguide.nl/new-york-l59/tickets-voor-de-new-york-botanical-garden-vakantiebelevenis-t186753/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=kerstinnycbotanicalgardenintekst\" target=\"_blank\" rel=\"noopener\"><strong>Botanical Holiday Train</strong></a> is de moeite waard om te bezoeken in de kerstperiode. En wil je alle lichtjes zien? Dan is een <strong>feestlichten wandeling</strong> een aanrader om te doen![/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][thb_postbackground source=\"size:1|post_type:post|by_id:-667,13709\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1698998727454{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"550px\"][vc_custom_heading text=\"Dyker Heights\" font_container=\"tag:div|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"De ultieme plek om kerstlichtjes te bekijken\" font_size=\"60\" line_height=\"60\" font_color=\"#ffffff\"][vc_empty_space height=\"550px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"9680\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Kerst in New York City\" font_size=\"45\" line_height=\"45\" font_color=\"#c59c4d\"][ultimate_heading main_heading=\"De beste kerstactiviteiten in New York\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Met deze activiteiten en rondleidingen in New York kom je helemaal in de kerststemming!</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/4\"][ultimate_heading main_heading=\"Rockettes voorstelling\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][ultimate_heading main_heading=\"Vanaf \u20ac85\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_margin=\"margin-top:5px;margin-bottom:5px;\"][/ultimate_heading][vc_column_text]Een van de meest spectaculaire kerstvoorstellingen is ieder jaar weer te bekijken in Radio City Music Hall: The Rockettes. De jaarlijkse voorstelling met Rockettes, Santa Clause en Toy Soldiers is een unieke ervaring die je eigenlijk niet mag missen wanneer je rond de kerst in New York bent.[/vc_column_text][ultimate_heading main_heading=\"Praktische informatie\" heading_tag=\"div\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_column_text]<b>Locatie:</b>\u00a0 Radio City Music Hall\r\n<b>Let op</b>: Je krijgt een week voorafgaand aan de voorstelling instructies voor het downloaden van de tickets\r\n<strong>Kleding</strong>: Casual\r\n<strong>Niet toegestaan</strong>: Eten &amp; Drinken[/vc_column_text][thb_iconbox type=\"left type1\" animation=\"\" icon_image=\"19694\" icon_image_width=\"125\" heading=\"New York expert tip van Marjolein:\" description=\"De show van de Rockettes is fantastisch om te zien. Hoewel ik het al eens gezien heb, zou ik zo nog een keer willen gaan.\" thb_heading_color=\"#b34a4c\" thb_text_color=\"#282828\" heading_font_size=\"17px\" description_font_size=\"16px\"][ult_buttons btn_title=\"Boek deze tour\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fnew-york-city-radio-city-christmas-spectacular-t406291%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dkerstinnewyorkrockettes|title:Boek%20deze%20tour|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][vc_column_inner width=\"1/4\"][ultimate_heading main_heading=\"Feestlichten tour door New York\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][ultimate_heading main_heading=\"Vanaf \u20ac55\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_margin=\"margin-top:5px;margin-bottom:5px;\"][/ultimate_heading][vc_column_text]Met deze tour pak je twee dingen in \u00e9\u00e9n. Je kunt de mooiste lichtjes zien in New York en krijgt daarbij direct iconische kerst filmlocaties te zien in New York. Stap in de bus en ontdek iconische plekken, maar ook verborgen plekken tijdens de tour. Zie de plek waar Macaulay Culkin met zijn moeder werd herenigd in Home Alone 2 of bekijk de locaties uit Miracle on 34th Street.[/vc_column_text][ultimate_heading main_heading=\"Praktische informatie\" heading_tag=\"div\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_column_text]<b>Duur:</b>\u00a0 2,5 uur\r\n<b>Vertrek</b>: Broadway 1889 - gids staat bij de Starbucks\r\n<b>Let op: </b>Vervoer met een bus[/vc_column_text][ult_buttons btn_title=\"Boek deze tour\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fnew-york-holiday-lights-and-movie-sites-tour-t41221%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dkerstinnewyorkfeestlichten|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][vc_column_inner width=\"1/4\"][ultimate_heading main_heading=\"Botanical Holiday Train\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][ultimate_heading main_heading=\"Vanaf \u20ac33\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_margin=\"margin-top:5px;margin-bottom:5px;\"][/ultimate_heading][vc_column_text]Een jaarlijkse traditie in New York Botanical Garden is de feestelijke treinshow met kerst. Een modeltrein rijdt door een mini weergave van New York met vele herkenbare plekken. In deze periode is ook Glow in de Botanical Garden, waarbij de tuin versierd wordt met allemaal lichtjes. Een prachtige kerstervaring midden in New York Botanical Garden.[/vc_column_text][ultimate_heading main_heading=\"Praktische informatie\" heading_tag=\"div\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_column_text]<b>Adres:</b> 2950 Southern Blvd\r\n<b>Handig</b>: Je koopt een ticket voor Glow en de Holiday Train\r\n<b>Let op</b>: Neem je paspoort mee[/vc_column_text][ult_buttons btn_title=\"Boek deze tour\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fnew-york-botanical-garden-holiday-experience-tickets-t186753%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dkerstinnewyorkbotanicalholidaytrain|title:Boek%20deze%20tour|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][vc_column_inner width=\"1/4\"][ultimate_heading main_heading=\"Dyker Heights\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][ultimate_heading main_heading=\"Vanaf \u20ac55\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_margin=\"margin-top:5px;margin-bottom:5px;\"][/ultimate_heading][vc_column_text]Stap in Manhattan in de bus om de mooiste versierde wijk van New York te bekijken. In Dyker Heights in Brooklyn vind je over the top versieringen bij de huizen en muziek, een waar feestje. Een unieke ervaring om mee te maken. Al sinds de jaren 80 versieren de inwoners van Dyker Heights voor de feestdagen hun huizen. Bekijk samen met een gids de mooiste huizen in Dyker Heights.[/vc_column_text][ultimate_heading main_heading=\"Praktische informatie\" heading_tag=\"div\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_column_text]<b>Duur:</b>\u00a0 4 uur\r\n<b>Vertrek</b>: 566 10th Avenue, zoek de gids met Christmas Tour\r\n<b>Let op: </b>Breng warme kleren mee[/vc_column_text][thb_iconbox type=\"left type1\" animation=\"\" icon_image=\"19694\" icon_image_width=\"125\" heading=\"New York expert tip van Marjolein:\" description=\"De ultieme wijk voor kerstlichtjes in Dyker Heights, niets is te gek\" thb_heading_color=\"#b34a4c\" thb_text_color=\"#282828\" heading_font_size=\"17px\" description_font_size=\"16px\"][ult_buttons btn_title=\"Boek deze tour\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fbrooklyn-nyc-l2034%2Fdyker-heights-new-york-christmas-lights-tour-t128106%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dkerstinnewyorkdykerheights|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"95%\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1704447364483{background-color: #f2f2f2 !important;}\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"MEER PLEKJES?\r\nCHECK DE GRATIS HEY!USA APP!\" font_container=\"tag:h2|font_size:50|text_align:center|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_row_inner][vc_column_inner width=\"1/4\"][/vc_column_inner][vc_column_inner width=\"1/2\"][thb_image retina=\"retina_size\" alignment=\"aligncenter\" image=\"11640\" img_size=\"medium\" img_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fheyusa-app%2F|title:Hey!USA%20app|target:_blank\"][/thb_image][vc_custom_heading text=\"Honderden unieke, bijzondere, verborgen plekjes in New York City? Plus de klassiekers \u00e9n zien waar je bent in de stad? Download dan de gratis Hey!USA-app!\" font_container=\"tag:p|font_size:20|text_align:center|color:%23282828|line_height:1.5\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\" link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fheyusa-app%2F|title:Hey!USA%20app\"][ult_buttons btn_title=\"HEY!USA APP\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fheyusa-app%2F|title:Hey!USA%20app|target:_blank\" btn_align=\"ubtn-center\" btn_size=\"ubtn-small\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:25px;\" btn_line_height=\"desktop:30px;\"][vc_empty_space height=\"25px\"][/vc_column_inner][vc_column_inner width=\"1/4\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1606171128628{padding-top: 75px !important;padding-bottom: 75px !important;}\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"25px\"][vc_custom_heading text=\"Overnachten in New York:\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style4\" columns=\"4\" source=\"post_type:post|by_id:13891,6279,-931,-883,-850,-456,14763,13925\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Andere artikelen over New York\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:13474,9675,-1971,1484,1312\"][/vc_column][/vc_row]","post_title":"Kerst in New York","post_link":"https://www.heyusa.com/nl/kerst-in-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Kerst in New York bij het Rockefeller Center\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/11/rockefeller-center-kerst--300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden New York","post_tags":"New York","%_wpb_shortcodes_custom_css%":".vc_custom_1698998329302{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1698754868953{padding-top: 25px !important;}.vc_custom_1698754990167{padding-top: 25px !important;}.vc_custom_1698998683520{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1698998727454{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1704447364483{background-color: #f2f2f2 !important;}.vc_custom_1606171128628{padding-top: 75px !important;padding-bottom: 75px !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_last%":"2","%_edit_lock%":"1718106797:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"65","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"20017","%_yoast_wpseo_focuskw%":"Kerst in New York","%_yoast_wpseo_title%":"Kerst in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Kerst in New York, misschien wel de mooiste periode om de stad te bezoeken. Tal van lichtjes, muziek, schaatsmogelijkheden en kerstmarkten!","%_yoast_wpseo_linkdex%":"74","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"kerstactiviteiten New York\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"808 Eagle Point Rd, Peach Springs, AZ 86434, Verenigde Staten","%_wpgmp_location_city%":"Peach Springs","%_wpgmp_location_state%":"Arizona","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"36.011943","%_wpgmp_metabox_longitude%":"-113.8108372","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"9","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_primary_category%":"14","%_yoast_indexnow_last_ping%":"1717487151","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_opengraph-description%":"Kerst in New York, misschien wel de mooiste periode om de stad te bezoeken. Tal van lichtjes, muziek, schaatsmogelijkheden en kerstmarkten!","%_jetpack_memberships_contains_paid_content%":"","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","taxonomy=category":"Bezienswaardigheden New York","taxonomy=post_tag":"New York","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":13669,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Cadillac Ranch","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Cadillac Ranch\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/11/cadillac-ranch-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Cadillac Ranch</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"Boottocht van 90 minuten over de Hudson en East River","address":"13651 I-40 Frontage Rd, Amarillo, TX 79124, Verenigde Staten","location":{"lat":"35.1872366","city":"Amarillo","state":"Texas","country":"Verenigde Staten","lng":"-101.9870486","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/cadillac-ranch/","zoom":12,"extra_fields":{"post_excerpt":"Boottocht van 90 minuten over de Hudson en East River","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"30px\"][vc_custom_heading text=\"Cadillac Ranch\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een van de hoogtepunten aan Route 66 is de Cadillac Ranch. Een kunstproject in de buurt van Amarillo in Texas met een tiental oude Cadillacs die uit de grond steken. De Cadillacs, die allerlei verschillende kleuren hebben, staan onderste boven in de grond langs de kant van de weg. Een leuke stop op Route 66 of als je in de buurt bent van Amarillo.[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612949537564{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Het verhaal achter Cadillac Ranch\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Cadillac Ranch is een publieke kunstinstallatie dat gecre\u00eberd werd in 1974 door de groep Ant Farm. Tien Cadillacs die gebouwd werden tussen 1949 en 1963 staan met hun neus in de grond. Het project werd gefinancierd door miljonair Stanley Marsh 3. Ze symboliseren niet alleen de succesvolle productie van de Cadillac, maar ook de liefde voor auto's van de Amerikanen. In 1997 werd de ranch 3 kilometer verderop geplaatst omdat de grenzen van Amarillo dichterbij kwamen.[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Allemaal spuitbussen voor de Cadillacs\" font_container=\"tag:div|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Maak je eigen streetart op de auto's\" font_size=\"55\" line_height=\"60\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"13542\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Cadillac Ranch bezoeken\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Hoewel Cadillac Ranch zich bevindt op een priv\u00e9 land, is het kosteloos te bezoeken. Je kunt zelfs je eigen spuitbussen meenemen om ook aan de slag te gaan op de auto's. Naast de auto's liggen her en der gebruikte spuitbussen. Af en toe worden de auto's in een specifieke kleur geschilderd. Met de dood van George Floyd in 202o werden ze volledig zwart geschilderd en tijdens de Gay Pride van 2012 werden ze in regenboog kleuren geschilderd.\r\n\r\nJe vindt <a href=\"https://www.visitamarillo.com/listing/cadillac-ranch/625/\" target=\"_blank\" rel=\"noopener\">Cadillac Ranch</a> aan de I40 op een koeienweide. Het is zichtbaar vanaf de snelweg en je dient door een niet afgesloten poort te lopen om bij de Cadillacs te komen.[/vc_column_text][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>13651 I-40 Frontage Rd net buiten Amarillo</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>24/7</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"10 Cadillacs in een open veld\" font_container=\"tag:div|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Een must-do tijdens een Route 66 roadtrip!\" font_size=\"55\" line_height=\"60\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"13544\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Andere leuke artikelen\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:13381,8043,7275,4509\"][/vc_column][/vc_row]","post_title":"Cadillac Ranch","post_link":"https://www.heyusa.com/nl/cadillac-ranch/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Cadillac Ranch\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/11/cadillac-ranch-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden","post_tags":"Texas","%_wpb_shortcodes_custom_css%":".vc_custom_1612949537564{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1679662181:1","%_wpb_vc_js_status%":"true","%post-primary-category%":"65","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"13543","%_yoast_wpseo_focuskw%":"Cadillac Ranch","%_yoast_wpseo_title%":"Cadillac Ranch Amarillo %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een leuke attractie aan Route 66 is de Cadillac Ranch. Tips voor een bezoek aan de Cadillac Ranch in Amarillo Texas.","%_yoast_wpseo_linkdex%":"80","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"360 Chicago Observation Deck\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"13651 I-40 Frontage Rd, Amarillo, TX 79124, Verenigde Staten","%_wpgmp_location_city%":"Amarillo","%_wpgmp_location_state%":"Texas","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"35.1872366","%_wpgmp_metabox_longitude%":"-101.9870486","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_primary_category%":"65","%_yoast_indexnow_last_ping%":"1679659650","%_wp_old_date%":"2022-11-17","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Bezienswaardigheden","taxonomy=post_tag":"Texas","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":13715,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"360 Chicago","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"360 Chicago\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/10/uitzicht-chicago-360-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">360 Chicago</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"Boottocht van 90 minuten over de Hudson en East River","address":"875 N Michigan Ave 94th floor, Chicago, IL 60611, Verenigde Staten","location":{"lat":"41.8989423","city":"Chicago","state":"Illinois","country":"Verenigde Staten","lng":"-87.6235437","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/360-chicago/","zoom":12,"extra_fields":{"post_excerpt":"Boottocht van 90 minuten over de Hudson en East River","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"30px\"][vc_custom_heading text=\"360 Chicago\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In een stad waar tal van skyscrapers staan, kan een uitzichtpunt natuurlijk niet ontbreken. In het John Hancock Center in Chicago, het derde hoogste gebouw van de stad, vind je op de 94e verdieping het 360 Chicago Observation Deck. Een observatiedeck, met hoe kan het ook anders dan de naam doet vermoeden, een 360 graden uitzicht over Chicago. En het 360 Chicago Observation Deck heeft nog wat extra's te bieden voor een ieder die durft. Benieuwd wat dat is? Lees dan snel verder over het 360 Chicago Observation Deck![/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf $30 per persoon[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612949537564{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Over 360 Chicago Observation Deck - TILT\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Naast het 360 graden uitzicht over Chicago heeft het John Hancock Center nog iets spectaculairs te bieden en het is voor mensen met een sterke maag. Je kunt namelijk bij de attractie TILT testen hoe het is gesteld met je hoogtevrees. Bij een raam aan de buitenzijde van het gebouw wordt een deel 30 graden gekanteld. Hierdoor kijk je recht naar beneden over de straten van Chicago. Durf jij het aan?[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"John Hancock Center\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"100 verdieping tellende gebouw - 360 Chicago zit op de 94e verdieping\" font_container=\"tag:div|font_size:45|text_align:center\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"13403\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tickets voor 360 Chicago Observation Deck\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het 360 Chicago Observation Deck is een van de populairste attracties in Chicago. Neem sowieso de tijd om het uitzicht te bewonderen, maar ook om de attractie te bezoeken. Het is niet gek dat er lange wachtrijen zijn. Wil je deze overslaan? Koop dan een '<a href=\"https://www.getyourguide.com/chicago-l225/john-hancock-observatory-chicago-s-best-views-t31619/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=chicago360skipthelinetekst\" target=\"_blank\" rel=\"noopener\">skip the line ticket</a>'.[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fchicago-l225%2Fjohn-hancock-observatory-chicago-s-best-views-t31619%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dchicago360skiptheline\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_custom_heading text=\"Restaurant en Lounge Bar in het John Hancock Center\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In het John Hancock Center zijn nog twee verdiepingen open voor publiek. Op de 95e verdieping vind je het Signature Room Restaurant en op de 96e verdieping de Signature Lounge Bar. Op grote hoogte dineren of een drankje doen onder het genot van uitzicht over Chicago, wie wil dat nou niet? Beiden een unieke, maar enigszins prijzige belevenis.[/vc_column_text][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>875 N Michigan Ave 94th floor Chicago</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Dagelijks van 09.00 - 23.00 uur, laatste entree is 1 uur voor sluiting</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"360 Chicago\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"TILT - Durf jij het aan?\" font_container=\"tag:div|font_size:45|text_align:center\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"13404\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Andere leuke artikelen\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:12074,4076,2150,1971,2165\"][/vc_column][/vc_row]","post_title":"360 Chicago","post_link":"https://www.heyusa.com/nl/360-chicago/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"360 Chicago\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/10/uitzicht-chicago-360-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Chicago","post_tags":"Illinois","%_wpb_shortcodes_custom_css%":".vc_custom_1612949537564{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1669214038:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"65","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"13405","%_yoast_wpseo_focuskw%":"360 Chicago","%_yoast_wpseo_title%":"360 Chicago Observation Deck %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een van de populairste attracties in Chicago is het 360 Chicago Observation Deck. Bestel hier je tickets en alle tips voor een bezoek!","%_yoast_wpseo_linkdex%":"76","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"360 Chicago Observation Deck\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"875 N Michigan Ave 94th floor, Chicago, IL 60611, Verenigde Staten","%_wpgmp_location_city%":"Chicago","%_wpgmp_location_state%":"Illinois","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"41.8989423","%_wpgmp_metabox_longitude%":"-87.6235437","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_primary_category%":"65","%_yoast_indexnow_last_ping%":"1677014934","taxonomy=category":"Bezienswaardigheden Chicago","taxonomy=post_tag":"Illinois","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":13401,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"World of Coca Cola in Atlanta","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coca Cola World\" width=\"300\" height=\"199\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/10/coca-cola-world-300x199.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">World of Coca Cola in Atlanta</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"Boottocht van 90 minuten over de Hudson en East River","address":"121 Baker St NW, Atlanta, GA 30313, Verenigde Staten","location":{"lat":"33.7625564","city":"Atlanta","state":"Georgia","country":"Verenigde Staten","lng":"-84.39243599999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/world-of-coca-cola-atlanta/","zoom":12,"extra_fields":{"post_excerpt":"Boottocht van 90 minuten over de Hudson en East River","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"30px\"][vc_custom_heading text=\"World of Coca Cola Atlanta\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Wie kent het beroemde drankje Coca Cola niet? In Atlanta kun je World of Coca Cola bezoeken, een permanente tentoonstelling over Coca Cola. Hier kom je alles te weten over de geschiedenis van een van 's werelds bekendste drankjes. Ben je in Atlanta? Dan ken een bezoek aan World of Coca Cola niet ontbreken, hierbij alle tips voor een bezoek.[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf $20 per persoon[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612949537564{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Over World of Coca Cola\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Ontdek alles over Coca Cola aan de hand van interactieve exposities. Leer meer over de geschiedenis van het drankje, kom het verhaal achter het bottelproces te weten en natuurlijk kun je World of Coca Cola niet verlaten zonder een van de 100 verschillende drankjes geproefd te hebben. In de tentoonstelling Scent Discovery moet je zelf aan de bak. Gebruik je neus om de oorsprong te raden van de verschillende geuren. World of Coca Cola is een interactief museum dat voor iedere doelgroep geschikt is!</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Coca Cola Walhalla\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Leer alles over Coca Cola\" font_container=\"tag:div|font_size:45|text_align:center\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"13318\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tickets voor World of Coca Cola\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Je kunt voor een bezoek aan World of Coca Cola het beste vooraf kaartjes kopen. Hierdoor kun je direct naar de hoofdingang en hoef je niet te wachten in een rij. Bestel je kaartjes online en verspil geen tijd aan wachten in rijen![/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fworld-of-coca-cola-l76765%2Fatlanta-world-of-coca-cola-skip-the-line-ticket-t388500%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dcocacolaworldbanner\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>121 Baker St NW, Atlanta, GA 30313, Verenigde Staten</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Dagelijks van 08.00 - 18.00 uur, laatste tickets worden rond 15.30 uur verkocht</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Andere leuke artikelen\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:13299,12854,12074,12063,1971\"][/vc_column][/vc_row]","post_title":"World of Coca Cola in Atlanta","post_link":"https://www.heyusa.com/nl/world-of-coca-cola-atlanta/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coca Cola World\" width=\"300\" height=\"199\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/10/coca-cola-world-300x199.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden","post_tags":"Georgia","%_wpb_shortcodes_custom_css%":".vc_custom_1612949537564{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1669214067:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"65","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"13319","%_yoast_wpseo_focuskw%":"World of Coca Cola Atlanta","%_yoast_wpseo_title%":"World of Coca Cola in Atlanta %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"World of Coca Cola in Atlanta leert je alles over het beroemde drankje. Tips voor een bezoek aan World of Coca Cola Atlanta","%_yoast_wpseo_linkdex%":"65","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"World of Coca Cola\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"121 Baker St NW, Atlanta, GA 30313, Verenigde Staten","%_wpgmp_location_city%":"Atlanta","%_wpgmp_location_state%":"Georgia","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"33.7625564","%_wpgmp_metabox_longitude%":"-84.39243599999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_primary_category%":"65","%_yoast_indexnow_last_ping%":"1677014939","taxonomy=category":"Bezienswaardigheden","taxonomy=post_tag":"Georgia","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":13317,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Grand Canyon Skywalk","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Grand Canyon Skywalk\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/10/Grand-Canyon-skywalk-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Grand Canyon Skywalk</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"Een zwevend platform van glas boven de Grand Canyon, durf jij het aan?","address":"808 Eagle Point Rd, Peach Springs, AZ 86434, Verenigde Staten","location":{"lat":"36.011943","city":"Peach Springs","state":"Arizona","country":"Verenigde Staten","lng":"-113.8108372","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/grand-canyon-skywalk/","zoom":12,"extra_fields":{"post_excerpt":"Een zwevend platform van glas boven de Grand Canyon, durf jij het aan?","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"30px\"][vc_custom_heading text=\"Grand Canyon Skywalk\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Een zwevend platform van glas boven de Grand Canyon, durf jij het aan? Wandel</span><span style=\"font-weight: 400;\"> de Grand Canyon Skywalk op die op meer dan 300 tot 400 meter boven de Grand Canyon ligt. Het hoefijzervormige balkon steekt 22 meter over de Grand Canyon vanwaar je de Colorado Rivier op 1200 diepte verderop ziet liggen. De Grand Canyon Skywalk is voor mensen zonder hoogtevrees en echt een belevenis om mee te maken!</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-arrows-v\"]300-400 meter hoog[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]$49-$53 per persoon[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-group users\"]Zelf foto's maken niet toegestaan[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612949537564{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Over The Skywalk\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">De Grand Canyon Skywalk bevindt zich in Hualapai-indianenreservaat. De attractie werd geopend op 21 maart 2017 door astronaut Buzz Aldrin die samen met Hualapai indianen de eerste stappen zette op de skywalk. Op de Skywalk mogen 800 mensen tegelijk, maar de limiet hebben ze gezet op 120 mensen per keer. De gehele bouw van de Skywalk heeft 30 miljoen dollar gekost. De prijzen voor een ticket liggen daardoor vrij hoog en het maken van foto's is niet toegestaan. Dit doet het aanwezige personeel en foto's kunnen nadien gekocht worden voor relatief hoge prijzen.</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"300-400m diep\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"... en een glazen ondergrond!\" font_container=\"tag:div|font_size:45|text_align:center\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"13187\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tickets voor The Grand Canyon Skywalk\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Je kunt voor een bezoek aan de Skywalk verschillende tickets kopen. Zo kun je een los ticket aanschaffen en zelf de rit maken richting de Grand Canyon Skywalk, maar er zijn ook diverse opties voor tours richting de Skywalk die aan te raden zijn.\r\n\r\n[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fgrandcanyonwest.com%2F\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>808 Eagle Point Road, Peach Springs Arizona</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Dagelijks van 08.00 - 18.00 uur, laatste tickets worden rond 15.30 uur verkocht</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][ultimate_heading main_heading=\"Tours naar de Grand Canyon Skywalk\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Met deze tours naar de Grand Canyon Skywalk, haal je het ultieme uit je trip.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Bus tour vanuit Las Vegas\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][ultimate_heading main_heading=\"Vanaf \u20ac200\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_margin=\"margin-top:5px;margin-bottom:5px;\"][/ultimate_heading][vc_column_text]Met deze tour vanuit Las Vegas heb je de mogelijkheid om de Grand Canyon op verschillende manieren te bekijken. Je bezoekt de beroemde Skywalk, maar ook minder bekende plekken als Eagle en Guano Points om te genieten van het uitzicht over de Grand Canyon. Na de Grand Canyon wordt er ook nog een stop gemaakt bij de Hoover Dam.[/vc_column_text][ultimate_heading main_heading=\"Praktische informatie\" heading_tag=\"div\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_column_text]<b>Handig:</b>\u00a0 Ophalen bij hotel, lunch inbegrepen\r\n<b>Vertrek</b>: Eigen hotel\r\n<b>Let op</b>: Mensen met hoogtevrees, je loopt over een glas met daaronder een diepe afgrond[/vc_column_text][ult_buttons btn_title=\"Boek deze tour\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Flas-vegas-l58%2Flas-vegas-small-group-grand-canyon-skywalk-tour-with-meals-t345276%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3DskywalkGCbustour|title:Boek%20deze%20tour|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Helikoptervlucht naar de Skywalk\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][ultimate_heading main_heading=\"Vanaf \u20ac590\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_margin=\"margin-top:5px;margin-bottom:5px;\"][/ultimate_heading][vc_column_text]Wil je echt de ultieme ervaring? Boek dan deze helikoptervlucht naar de West Rim van de Grand Canyon. Je vertrekt vanuit Las Vegas en vliegt naar de West Rim, via Lake Mead en de Hoover Dam naar de Skywalk. Hier heb je VIP toegang om de mooiste uitzichten te zien vanaf de Skywalk. Je ziet dus de Las Vegas Strip, Lake Mead, de Hoover Dam \u00e9n de Grand Canyon allemaal vanuit de lucht![/vc_column_text][ultimate_heading main_heading=\"Praktische informatie\" heading_tag=\"div\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_column_text]<b>Duur:</b>\u00a0 4,5 uur waarvan 45 minuten grondtijd in Grand Canyon West\r\n<b>Vertrek</b>: ophaalservice mogelijk\r\n<b>Let op: </b>Als je de reservering minder dan 48 uur voor de geplande vluchttijd annuleert, dan krijg je geen geld terug.[/vc_column_text][ult_buttons btn_title=\"Boek deze tour\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Flas-vegas-l58%2Fgrand-canyon-skywalk-express-helicopter-tour-t7217%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3DskywalkGChelikopter|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"95%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Enjoy the view!\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_custom_heading text=\"Grand Canyon National Park\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:3\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"13185\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Andere artikelen over de Grand Canyon\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:3223,3208,1971,17060\"][/vc_column][/vc_row]","post_title":"Grand Canyon Skywalk","post_link":"https://www.heyusa.com/nl/grand-canyon-skywalk/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Grand Canyon Skywalk\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/10/Grand-Canyon-skywalk-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Grand Canyon National Park","post_tags":"Arizona","%_wpb_shortcodes_custom_css%":".vc_custom_1612949537564{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"2","%_edit_lock%":"1691746581:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"65","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"13182","%_yoast_wpseo_focuskw%":"Grand Canyon Skywalk","%_yoast_wpseo_title%":"Grand Canyon Skywalk %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Grand Canyon Skywalk is een van de trekpleisters in de buurt van de Grand Canyon. Stap op de glazen plaat voor een fantastisch uitzicht!","%_yoast_wpseo_linkdex%":"75","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"808 Eagle Point Rd, Peach Springs, AZ 86434, Verenigde Staten","%_wpgmp_location_city%":"Peach Springs","%_wpgmp_location_state%":"Arizona","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"36.011943","%_wpgmp_metabox_longitude%":"-113.8108372","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_primary_category%":"33","%_yoast_indexnow_last_ping%":"1691738741","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Grand Canyon National Park","taxonomy=post_tag":"Arizona","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":13179,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Universal Studios Hollywood Los Angeles","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Universal Studios\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/09/Universal-Studios-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Universal Studios Hollywood Los Angeles</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"100 Universal City Plaza, Universal City, CA 91608, Verenigde Staten","location":{"lat":"34.13811680000001","city":"Universal City","state":"California","country":"Verenigde Staten","lng":"-118.3533783","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/universal-studios-hollywood-los-angeles/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"25px\"][ultimate_heading main_heading=\"Universal Studios Hollywood\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]<strong>Neem een kijkje achter de schermen van een van de grootste filmstudio's en attractieparken ter wereld. Bekijk niet alleen de plekken waar blockbusters en televisie series worden gemaakt en voel de adrenaline in de verschillende attracties. Universal Studios Hollywood is de plek om de ins en outs van de filmwereld te ontdekken en ondertussen kun je alle toffe en uitdagende attracties uit proberen.\r\n</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"1000 Universal Studios Blvd\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"VIP tickets? Boek deze hier!\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Flos-angeles-l179%2Funiversal-studios-hollywood-the-vip-experience-t74386%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Duniversalstudiosviptop|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Filmstudio en themapark in \u00e9\u00e9n\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Waar <a href=\"https://www.getyourguide.com/los-angeles-l179/universal-studios-hollywood-the-vip-experience-t74386/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=universalstudiosviptekst\" target=\"_blank\" rel=\"noopener\">Universal Studios</a> ooit begon met alleen een rondleiding achter de schermen van de filmwereld, groeide het uiteindelijk uit tot een van de meest bezochte attractieparken in Amerika. De originele studio's zijn nog steeds in gebruik voor hedendaagse producties als Desperate Housewives. In 1964 werd Universal Studios geopend en sindsdien zijn er tal van uitbreidingen naast de studio tour bijgekomen. Vaak met attracties die verwijzen naar de blockbusters in de studios. Denk aan Blues Brothers, Shrek, King Kong, The Simpsons of Jurassic Park,</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Universal Studios\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Actie, adrenaline en filmstunts\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"12870\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Universal Studios\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Achtbanen\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Een attractiepark kan natuurlijk niet zonder achterbanen. Een van de snelste achtbanen ter wereld is de Fast &amp; Furious en die vind je in Universal Studios. Hij gaat meer 190 kilometer per uur. Of stap in de Flight of the Hippogriff om de Magic van Harry Potter te ontdekken. Als laatste kan een ritje in Revenge of the Mummy ook niet ontbreken wanneer je van achtbanen houdt.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"World Famous Studio Tour\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In de studio tour van Universal Studios in Hollywood kom je achter de schermen van een echte filmstudio. De studio is meer dan 13 blokken groot en staat vol met attributen uit de filmwereld. Kijk welke decors uit films en series jij kunt ontdekken tijdens deze 60 minuten durende tour.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Waterwold\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]WaterWorld is de best beoordeelde show van Universal Studios. Doe mee aan een avontuur dat tot leven komt met jetski\u00ebrs, duikvluchten, vuurgevechten en explosies. Een show die je niet mag missen in Universal Studios.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Ontdek Universal Studios achter de schermen\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Tour door Universal Studios\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"12869\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ook leuk in Los Angeles\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][fullwidth_row][thb_postgrid columns=\"4\" source=\"post_type:post|by_id:8343,7708,7537,7503\"][/vc_column][/vc_row]","post_title":"Universal Studios Hollywood Los Angeles","post_link":"https://www.heyusa.com/nl/universal-studios-hollywood-los-angeles/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Universal Studios\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/09/Universal-Studios-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Los Angeles","post_tags":"Californi\u00eb","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1669884458:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"65","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Universal Studios Hollywood","%_yoast_wpseo_title%":"Universal Studios Hollywood %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Alles over de Universal Studios in Hollywood. Tips voor het bezoeken van de Universal Studios in Hollywood Los Angeles","%_yoast_wpseo_linkdex%":"81","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Universal Studios\"]","%_wpgmp_location_address%":"100 Universal City Plaza, Universal City, CA 91608, Verenigde Staten","%_wpgmp_location_city%":"Universal City","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"34.13811680000001","%_wpgmp_metabox_longitude%":"-118.3533783","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"12871","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"65","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677014947","taxonomy=category":"Bezienswaardigheden Los Angeles","taxonomy=post_tag":"Californi\u00eb","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":12865,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Pentagon","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pentagon\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/Pentagon-vanuit-de-lucht-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Pentagon</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Washington D.C., District of Columbia 22202, Verenigde Staten","location":{"lat":"38.8718568","city":"Washington D.C.","state":"District of Columbia","country":"Verenigde Staten","lng":"-77.0562669","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/pentagon-washington/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][ultimate_heading main_heading=\"Pantagon in Washington\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]<span style=\"font-weight: 400;\">Een merkwaardig gebouw</span><span style=\"font-weight: 400;\"> huisvest het Amerikaanse ministerie van Defensie: het Pentagon in Washington. Het gebouw is in een regelmatige vijfhoek gebouwd, een pentagoon. Hier vind je het hoofdkwartier van de Amerikaanse strijdkrachten. Lees meer over het dit unieke gebouw!\r\n</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]Tours op maandag t/m donderdag: 10.00 -16.00 uur\r\nVrijdag van 12.00 - 16.00 uur[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Gratis -$1 fee wanneer je <a href=\"https://pentagontours.osd.mil/Tours/\" target=\"_blank\" rel=\"noopener noreferrer\">online</a> besteld[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Wat is het Pentagon?\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">Het Pentagon is een van de meest effici\u00ebnte kantoorgebouwen dat er is. In zeven minuten is namelijk iedere plek te bereiken ondanks dat het een g</span>angen stelsel <span style=\"font-weight: 400;\">heeft van 28 kilometer. In het gebouw werken in totaal meer dan 26.000 mensen! Daarmee is het het grootste kantoorgebouw ter wereld. De laatste grote renovatie vond plaats in 1998, het gebouw voldeed niet meer aan de eisen. Vele kabels en leidingen werden vervangen, ook de ventilatie voldeed niet meer aan de eisen. Je kunt het Pentagon bezoeken tijdens een rondleiding. Het is niet gemakkelijk om dat voor elkaar te krijgen. Via de Nederlandse ambassade in Washington D.C. kun je een aanvraag doen.</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"9/11 Memorial\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Ook het Pentagon werd getroffen op 9/11\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"7232\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Interessante weetjes over het Pentagon\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]Ten tijde van de Tweede Wereldoorlog, onder leiding van President Roosevelt, werd het Pentagon gebouwd. Na 16 maanden van bouwen werd het in 1943 geopend. Aanvankelijk dachten ze dat het een tijdelijk gebouw zou worden, maar het is nog steeds in gebruik als het hoofdkwartier van de Amerikaanse militaire strijdkrachten. De totale oppervlakte is 2,4km\u00b2, er zijn 8770 parkeerplaatsen, de hoogte is 24 meter en er zijn 7 verdiepingen in het Pentagon, waarvan er in ieder geval 5 bovengronds liggen.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"De aanslagen van 9/11 op het Pentagon\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Niet alleen New York werd geraakt op <a href=\"https://www.heyusa.com/nl/new-york-city/9-11-museum-memorial/\" target=\"_blank\" rel=\"noopener noreferrer\">9-11-2001</a>, ook het Pentagon in Washington was een doelwit. American Airlines vlucht 77, onderweg van Washington naar Los Angeles, boorde zich om 9.37 AM in een buitengevel van het Pentagon. Er vielen 184 doden bij deze aanslag. Een geluk bij een ongeluk, het vliegtuig raakte een van de delen die net gerenoveerd was en daardoor een stuk sterker dan de overige delen van het gebouw. Hierdoor waren de kantoren minder bezet dan normaal.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"De kantoren van het Pentagon\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Hoofdkantoor van de militaire strijdkrachten\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"7238\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Ook leuk in Washington\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:1910,1937,1961,1925\"][/vc_column][/vc_row]","post_title":"Pentagon","post_link":"https://www.heyusa.com/nl/pentagon-washington/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pentagon\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/Pentagon-vanuit-de-lucht-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Washington D.C.","post_tags":"Washington D.C.","%_wpb_shortcodes_custom_css%":".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}","%_edit_last%":"1","%_edit_lock%":"1669968984:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"22","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_yoast_wpseo_focuskw%":"Pentagon in Washington","%_yoast_wpseo_title%":"%%title%% in Washington%%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"In het Pentagon in Washington vind je het Amerikaanse ministerie van Defensie. Interessante weetjes over het Pentagon in Washington.","%_yoast_wpseo_linkdex%":"82","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Pentagon\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"Washington D.C., District of Columbia 22202, Verenigde Staten","%_wpgmp_location_city%":"Washington D.C.","%_wpgmp_location_state%":"District of Columbia","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.8718568","%_wpgmp_metabox_longitude%":"-77.0562669","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_thumbnail_id%":"7234","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677014949","%_wp_old_date%":"2020-09-22","taxonomy=category":"Bezienswaardigheden Washington D.C.","taxonomy=post_tag":"Washington D.C.","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":1966,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Arlington National Cemetery","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Arlington Cemetary\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/Arlington-Cemetary-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Arlington National Cemetery</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Arlington, Virginia, Verenigde Staten","location":{"lat":"38.8768684","city":"Arlington","state":"Virginia","country":"Verenigde Staten","lng":"-77.0707857","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/arlington-national-cemetery-washington/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][ultimate_heading main_heading=\"Arlington National Cemetery Washington\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]<span style=\"font-weight: 400;\">De Verenigde Staten kent 139 nationale begraafplaatsen en een van de meest bekende is Arlington National Cemetery in Washington. Officieel is het een militaire begraafplaats, maar er liggen ook bekende Amerikanen. Er zijn grafstenen van presidenten, astronauten, politici en verdienstelijke burgers. De indrukwekkende begraafplaats ligt op een groene heuvel met uitzicht over Washington D.C.\r\n</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]Dagelijks: 08.00 -17.00 uur[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Gratis -$1 fee wanneer je online besteld[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Informatie over het Arlington National Cemetery\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">De eerste begrafenis vond plaats in 1864 en sindsdien zijn er ongeveer 15 begrafenissen per dag. Inmiddels zijn er meer dan 400.000 graven. Op de begraafplaats vind je ook het Netherlands Carillon, een gift vanuit de Nederlandse bevolking.</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Arlington Cemetery\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\" margin_design_tab_text=\"\"][/ultimate_heading][ultimate_heading main_heading=\"Tomb of the Unknown Soldier\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"6904\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Weetjes over het Arlington National Cemetery\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]<span style=\"font-weight: 400;\">Naast alle graven zijn er ook een aantal monumenten. Een daarvan is het graf van de Onbekende Soldaat. Dit monument stamt nog uit de Eerste Wereldoorlog. In 1921 werden vier kisten met resten van vier Amerikaanse soldaten naar Ch\u00e2lons-sur-Marne in Frankrijk gebracht. Hierna werden de kisten naar <a href=\"https://www.arlingtoncemetery.mil/\" target=\"_blank\" rel=\"noopener noreferrer\">Arlington National Cemetery</a> gebracht. Op het monument staat de volgende tekst: <i>Here Rests in Honored Glory, An American Soldier, Known but to God.\u00a0</i>Later werden ook monumenten voor onbekende soldaten uit de Tweede Wereldoorlog, de oorlog in Korea en Vietnam toegevoegd.\u00a0</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Bezoek aan het Arlington National Cemetery\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]<span style=\"font-weight: 400;\">Op de begraafplaats liggen naast militairen ook bekende Amerikanen. De volgende presidenten en bekende Amerikanen liggen er begraven:\r\n- John F. Kennedy (35e president)\r\n- Jaqueline Bouvier Kennedy Onassis (first lady Verenigde Staten)\r\n- William Howard Taft (27e president)\r\n- John S. McCain Jr. (admiraal en vader van senator en presidentskandidaat John McCain)\r\n</span><span style=\"font-weight: 400;\">- Lee Marvin (filmacteur)\r\n- Fay Bainter (filmactrice)\r\n- James Benson Irwin (8e mens op de maan)</span>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Nederlands tintje op Arlington\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\" margin_design_tab_text=\"\"][/ultimate_heading][ultimate_heading main_heading=\"Netherlands Carillon\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"6906\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"75%\"][ultimate_heading main_heading=\"Ook leuk in Washington\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\" margin_design_tab_text=\"\"][/ultimate_heading][thb_postgrid excerpts=\"true\" columns=\"4\" source=\"by_id:1953,1937,1925,1910\"][/vc_column][/vc_row]","post_title":"Arlington National Cemetery","post_link":"https://www.heyusa.com/nl/arlington-national-cemetery-washington/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Arlington Cemetary\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/Arlington-Cemetary-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Washington D.C.","post_tags":"Washington D.C.","%_wpb_shortcodes_custom_css%":".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}","%_edit_last%":"2","%_edit_lock%":"1678544693:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"15","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_yoast_wpseo_focuskw%":"Arlington National Cemetery in Washington","%_yoast_wpseo_title%":"%%title%% in Washington %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een van de meest indrukwekkende begraafplaatsen is het Arlington National Cemetery in Washington. Wat mag je niet missen tijdens je bezoek?","%_yoast_wpseo_linkdex%":"76","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"Arlington, Virginia, Verenigde Staten","%_wpgmp_location_city%":"Arlington","%_wpgmp_location_state%":"Virginia","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.8768684","%_wpgmp_metabox_longitude%":"-77.0707857","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"3510","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1678544690","%_wp_old_date%":"2020-09-22","taxonomy=category":"Bezienswaardigheden Washington D.C.","taxonomy=post_tag":"Washington D.C.","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":1961,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Washington Monument","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Washington Monument\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Washington-Monument-1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Washington Monument</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"2 15th St NW, Washington, D.C., DC 20024, Verenigde Staten","location":{"lat":"38.8894838","city":"Washington, D.C.","state":"District of Columbia","country":"Verenigde Staten","lng":"-77.0352791","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/washington-monument/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][ultimate_heading main_heading=\"Washington Monument\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]<span style=\"font-weight: 400;\">De grootste obelisk ooit gemaakt ter wereld vind je in Washington: het Washington Monument. Met zijn 169 meter een opvallend gebouw in Washington en natuurlijk een herkenningspunt. Midden op <a href=\"https://www.heyusa.com/nl/washington-dc/national-mall/\" target=\"_blank\" rel=\"noopener noreferrer\">The National Mall</a> vind je deze obelisk die je ook nog eens kunt bezoeken!\r\n</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]Elke dag geopend: 09.00 -17.00 uur[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Gratis -$1 fee wanneer je online besteld[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Informatie over het Washington Monument\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">Hoewel je het misschien niet verwacht, kun je de 169 meter hoge obelisk bezoeken. Een lift neemt je in 1 minuut mee naar de top van het Washington Monument. Op het observatiedek heb je een panoramisch uitzicht over Washington en omgeving. Een prachtig uitzicht over The National Mall heb je sowieso!</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"169 meter hoge obelisk\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\" margin_design_tab_text=\"\"][/ultimate_heading][ultimate_heading main_heading=\"Herkenningspunt van de stad\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"6925\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Weetjes over het Washington Monument\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]<span style=\"font-weight: 400;\">In 1848 werd gestart met de bouw van het monument, pas in 1884 werd het voltooid. De Amerikaanse Burgeroorlog gooide roet in het eten waardoor een er een gebrek aan middelen was. Dit kun je nog steeds zien aan de huidige obelisk. Deze is namelijk gebouwd uit verschillende soorten marmer en heeft daardoor verschillende kleuren. Rond 45 meter hoogte zie je een overgang in kleuren, let maar eens op wanneer je het monument bekijkt!</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Tickets voor het Washington Monument\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]<span style=\"font-weight: 400;\">Sinds de renovatie in 2019 is het mogelijk om meer mensen naar het observatiedek te krijgen. Binnen een minuut zoef je naar boven terwijl je ondertussen een video van de National Park Service bekijkt. Eenmaal boven zie je fantastische gebouwen als het <a href=\"https://www.heyusa.com/nl/washington-dc/witte-huis-washington/\" target=\"_blank\" rel=\"noopener noreferrer\">Witte Huis</a>, <a href=\"https://www.heyusa.com/nl/washington-dc/capitool-washington/\" target=\"_blank\" rel=\"noopener noreferrer\">het Capitool</a> en het <a href=\"https://www.heyusa.com/nl/washington-dc/arlington-national-cemetery/\" target=\"_blank\" rel=\"noopener noreferrer\">Arlington National Cemetery</a>. <a href=\"https://www.nps.gov/wamo/index.htm\" target=\"_blank\" rel=\"noopener noreferrer\">Tickets</a> kun je vanaf 90 dagen voor aanvang van je bezoek aanschaffen, er zijn eventueel ook 'same-day' tickets beschikbaar op basis van beschikbaarheid.\u00a0\u00a0</span>[/vc_column_text][ult_buttons btn_title=\"Tickets? Boek deze hier!\" btn_link=\"url:https%3A%2F%2Fwww.nps.gov%2Fwamo%2Findex.htm|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"National Mall\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\" margin_design_tab_text=\"\"][/ultimate_heading][ultimate_heading main_heading=\"Uitzicht op het monument\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"6921\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Ook leuk in Washington\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\" margin_design_tab_text=\"\"][/ultimate_heading][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:1910,1937,699,1925\"][/vc_column][/vc_row]","post_title":"Washington Monument","post_link":"https://www.heyusa.com/nl/washington-monument/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Washington Monument\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Washington-Monument-1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Washington D.C.","post_tags":"Washington D.C.","%_wpb_shortcodes_custom_css%":".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}","%_edit_last%":"2","%_edit_lock%":"1678544709:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"22","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"6923","%_yoast_wpseo_focuskw%":"Washington Monument in Washington","%_yoast_wpseo_title%":"%%title%% in Washington %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Het meest bekende monument van de stad zie je al van verre. Tips voor je bezoek aan het Washington Monument in Washington.","%_yoast_wpseo_linkdex%":"81","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"2 15th St NW, Washington, D.C., DC 20024, Verenigde Staten","%_wpgmp_location_city%":"Washington, D.C.","%_wpgmp_location_state%":"District of Columbia","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.8894838","%_wpgmp_metabox_longitude%":"-77.0352791","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1678544707","%_wp_old_date%":"2020-09-22","taxonomy=category":"Bezienswaardigheden Washington D.C.","taxonomy=post_tag":"Washington D.C.","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":1953,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Lincoln Memorial","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lincoln Memorial\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Lincoln-Memorial-1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Lincoln Memorial</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"2 Lincoln Memorial Cir NW, Washington, D.C., DC 20002, Verenigde Staten","location":{"lat":"38.8892686","city":"Washington, D.C.","state":"District of Columbia","country":"Verenigde Staten","lng":"-77.050176","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/lincoln-memorial-washington/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][ultimate_heading main_heading=\"Lincoln Memorial in Washington\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]<span style=\"font-weight: 400;\">Het Lincoln Memorial in Washington vind je aan het einde van de <a href=\"https://www.heyusa.com/nl/washington-dc/national-mall/\" target=\"_blank\" rel=\"noopener noreferrer\">National Mall</a>, uitkijkend over alle memorials richting <a href=\"https://www.heyusa.com/nl/washington-dc/capitool-washington/\" target=\"_blank\" rel=\"noopener noreferrer\">Het Capitool</a>. De 16e president van Amerika heeft zijn eigen enorme standbeeld gekregen in Washington. Twee jaar nadat hij neergeschoten werd (1865) werd al nagedacht over een memorial voor Abraham Lincoln, pas in 1914 werd uiteindelijk begonnen met bouwen.\r\n</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar - 8.00 tot middernacht[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Gratis[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Informatie over het Lincoln Memorial in Washington\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">Het monument voor Abraham Lincoln is gemaakt in klassieke stijl. Met massieven pilaren en een marmeren beeld van Lincoln is het een indrukwekkend monument geworden. Het is ook een inspiratiebron geweest voor Martin Luther King die hier zijn beroemde speech gaf in 1963.\u00a0</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Abraham Lincoln\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\" margin_design_tab_text=\"\"][/ultimate_heading][ultimate_heading main_heading=\"Het bijna 6 meter hoge standbeeld\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"1938\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Weetjes over het Lincoln Memorial\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]<span style=\"font-weight: 400;\">Het Lincoln Monument telt 36 pilaren die elk een van de 36 toenmalige staten moet weergeven. Het beeld van Abraham Lincoln is 5,8 meter hoog, er werden meer dan 28 blokken van marmer gebruikt om dit te maken. Op de muur achter het monument staat de volgende tekst geschreven: <em><small>IN THIS TEMPLE, </small><small>AS IN THE HEARTS OF THE PEOPLE </small><small>FOR WHOM HE SAVED THE UNION, </small><small>THE MEMORY OF ABRAHAM LINCOLN </small><small>IS ENSHRINED FOREVER</small></em>\r\n</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"De beste tijd om het Lincoln Memorial te bezoeken\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]<span style=\"font-weight: 400;\">Je hebt natuurlijk het mooiste uitzicht op het memorial en de reflecting pools voor het memorial, wanneer het rustig is. In de vroege ochtend heb je kans dat je alleen bent. Een ander mooi moment om het memorial te bezoeken is na zonsondergang wanneer het prachtig verlicht is en er minder mensen zijn. Een van de plekken waar je het mooiste uitzicht hebt, is op het plekje waar Martin Luther King stond.\u00a0</span>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"National Mall\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Uitzicht op het monument\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"6921\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Ook leuk in Washington\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:1925,1910,699,1953\"][/vc_column][/vc_row]","post_title":"Lincoln Memorial","post_link":"https://www.heyusa.com/nl/lincoln-memorial-washington/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lincoln Memorial\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Lincoln-Memorial-1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Washington D.C.","post_tags":"Washington D.C.","%_wpb_shortcodes_custom_css%":".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}","%_edit_last%":"2","%_edit_lock%":"1678544724:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"22","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_yoast_wpseo_focuskw%":"Lincoln Memorial","%_yoast_wpseo_title%":"%%title%% in Washington %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een van de meest opvallende monumenten is het Lincoln Memorial in Washington. Een eerbetoon aan President Abraham Lincoln.","%_yoast_wpseo_linkdex%":"78","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"2 Lincoln Memorial Cir NW, Washington, D.C., DC 20002, Verenigde Staten","%_wpgmp_location_city%":"Washington, D.C.","%_wpgmp_location_state%":"District of Columbia","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.8892686","%_wpgmp_metabox_longitude%":"-77.050176","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_thumbnail_id%":"6920","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1678544722","%_wp_old_date%":"2020-09-16","taxonomy=category":"Bezienswaardigheden Washington D.C.","taxonomy=post_tag":"Washington D.C.","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":1937,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Het Capitool Washington","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Capitool\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Capitool-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Het Capitool Washington</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"First St SE, Washington, D.C., DC 20004, Verenigde Staten","location":{"lat":"38.8899389","city":"Washington, D.C.","state":"District of Columbia","country":"Verenigde Staten","lng":"-77.0090505","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/capitool-washington/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][ultimate_heading main_heading=\"Het Capitool in Washington\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]<span style=\"font-weight: 400;\">Een van de bekendste gebouwen in de omgeving van de National Mall is Het Capitool in Washington. In dit gebouw vindt de wetgevende macht van Amerika plaats. Zowel het Amerikaanse Senaat en het Huis van Afgevaardigden (samen het Congress) bevinden zich in het Capitool. Naast dat het van de buitenkant al een prachtig gebouw is, is ook de binnenkant zeer de moeite waard om te bekijken tijdens een tour.\r\n</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]Maandag t/m zaterdag 8.30 - 16.30 uur\r\nMet uitzondering van feestdagen[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Gratis[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Tips voor het Capitool in Washington\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">Het Capitool is in neoclassicistische stijl gebouwd net als het <a href=\"https://www.heyusa.com/nl/washington-dc/witte-huis-washington/\" target=\"_blank\" rel=\"noopener noreferrer\">Witte Huis</a>. Het centrale punt is de Rotunda van het Capitool, de koepel die je van verre al uit ziet steken boven het gebouw. Je kunt Het Capitool bezoeken tijdens een tour waarbij je kennis maakt met de hectiek van de Amerikaanse politiek. Want hoewel je tijdens de rondleiding allerlei plekken met historie bezoekt, gaat de politiek in Het Capitool gewoon door. En dat maakt een bezoek aan het Capitool speciaal.\u00a0</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Rotunda Capitool\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Een van de indrukwekkendste plekken in het Capitool\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"3531\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Weetjes over het Capitool\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]<span style=\"font-weight: 400;\">In Het Capitool bevindt zich onder andere een Hall of Statues waar standbeelden staan van twee beroemde inwoners van iedere staat. Zo herken je de standbeelden van George Washington, Ronald Reagan en Rosa Parks. Een van de mooiste plekken in Het Capitool is de Rotunda. De ronde hal is enorm indrukwekkend met zijn schilderingen en standbeelden.\r\n</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Met een tour door het Capitool\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]<span style=\"font-weight: 400;\">Wanneer je in Washington bent is een tour door Het Capitool een enorme aanrader. Niet alleen maak je kennis met een stukje Amerikaanse politiek, het gebouw is van binnen ook erg indrukwekkend. Zeker wanneer je in de koepel de Rotunda staat of in Hall of Statues. Je kunt <a href=\"https://www.visitthecapitol.gov/\" target=\"_blank\" rel=\"noopener noreferrer\">online gratis tickets</a> kopen voor een tour of de gok nemen door op de dag zelf te kijken of er same-day passes beschikbaar zijn. Let op, wanneer je Het Capitool in gaat is er strenge controle. Deodorant, eten en drinken zijn niet toegestaan om mee te nemen naar binnen.\r\n</span>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Indrukwekkende standbeelden\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Het Capitool ademt geschiedenis\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"1930\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Lees meer over Washington\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\" margin_design_tab_text=\"\"][/ultimate_heading][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:699,1937,1910,1953\"][/vc_column][/vc_row]","post_title":"Het Capitool Washington","post_link":"https://www.heyusa.com/nl/capitool-washington/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Capitool\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Capitool-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Washington D.C.","post_tags":"Washington D.C.","%_wpb_shortcodes_custom_css%":".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}","%_edit_last%":"2","%_edit_lock%":"1678544737:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"22","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"6919","%_yoast_wpseo_focuskw%":"Het Capitool in Washington","%_yoast_wpseo_title%":"Het Capitool in Washington %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een van de bekendste gebouwen is het Capitool in Washington. Tips voor je bezoek aan het Capitool in Washington.","%_yoast_wpseo_linkdex%":"81","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"First St SE, Washington, D.C., DC 20004, Verenigde Staten","%_wpgmp_location_city%":"Washington, D.C.","%_wpgmp_location_state%":"District of Columbia","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.8899389","%_wpgmp_metabox_longitude%":"-77.0090505","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_oembed_6f9013b7a31a0eb98945760b7acb48ac%":"<iframe title=\"Graf George &#039;Hannibal&#039; Peppard\" width=\"1170\" height=\"658\" src=\"https://www.youtube.com/embed/lvfnnXTocQA?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>","%_oembed_time_6f9013b7a31a0eb98945760b7acb48ac%":"1622668180","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1678544736","%_wp_old_date%":"2020-09-16","taxonomy=category":"Bezienswaardigheden Washington D.C.","taxonomy=post_tag":"Washington D.C.","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":1925,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Kennedy Space Center","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Kennedy Space Center\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/09/Kennedy-Space-Center-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Kennedy Space Center</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Florida 32899, Verenigde Staten","location":{"lat":"28.5728722","state":"Florida","country":"Verenigde Staten","lng":"-80.64898079999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/kennedy-space-center/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"25px\"][ultimate_heading main_heading=\"Kennedy Space Center\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]<strong>Het Kennedy Space Center is een van de hoogtepunten aan de oostkust van Zuid- Amerika. Het enorme ruimtevaartcomplex biedt interactieve ervaringen aan voor iedereen die meer wil weten over de ruimtevaart. Je leert over de geschiedenis van de ruimtevaart, de huidige ruimtevaart en de toekomst. Ontdek alles over de ruimtevaart sector in Amerika bij het Kennedy Space Center.\r\n</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Merrit Island\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fkennedy-space-center-visitor-complex-l90590%2Fkennedy-space-center-admission-skip-the-ticket-line-t172620%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dkennedyspacecentertop|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Kennedy Space Center\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Nadat eerdere ruimtevaartbasissen in Amerika steeds niet voldeden, werd na de oprichting van de NASA in 1958 gekozen voor Merrit Island als belangrijkste plek voor de ruimtevaart. Alle huizen in het gebied werd afgebroken of verplaatst op \u00e9\u00e9n huis na. Dit werd het quarantaineverblijf voor astronauten en hun families voor de laatste week van de lancering. Het zogenoemde Beach House is nog steeds in gebruik. Na de <a href=\"https://www.heyusa.com/nl/de-moord-op-john-f-kennedy/\">moord op John. F. Kennedy</a> werd het complex hernoemd tot het <a href=\"https://www.getyourguide.com/kennedy-space-center-visitor-complex-l90590/kennedy-space-center-admission-skip-the-ticket-line-t172620/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=kennedyspacecentertekst\" target=\"_blank\" rel=\"noopener\">Kennedy Space Center</a>.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Historie in het Kennedy Space Center\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Apollo Saturn V\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"12859\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Kennedy Space Center\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Rocket Garden\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In Rocket Garden kun je een aantal historische raketten bewonderen uit de begindagen van de ruimtevaart. Ook de laatste Delta Raket uit 2018 staat inmiddels tussen de verschillende raketten. Naast raketten als Atlantis en Saturnis kun je ook zelf ervaren hoe het is om gelanceerd te worden.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Cape Canaveral Then &amp; Now Tour\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Herbeleef de lancering van de eerste Amerikaanse satellieten in het Air Force Space and Missile Museum. De geschiedenis van de (militaire) ruimtevaart komt ruim aan bod. Zie de plekken waar de Apollo raketten de ruimte in werden gestuurd en waar de Apollo I met de astronauten verbrandde. Aan te raden is om deze tour ruim van te voren te boeken, hij is vaak uitverkocht.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"International Space Center\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">De Observation Room is de plek waar alle ruimtevaartcomponenten van het International Space Station worden uitgecheckt en klaargemaakt worden voor de aanstaande ruimtereis. Er staat een woonmodule waarin je kunt zien hoe astronauten leven en slapen.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"De geschiedenis van de Amerikaanse ruimtevaart\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Tientallen raketten om te bewonderen\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"12857\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ook leuk in Florida\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][fullwidth_row][thb_postgrid columns=\"4\" source=\"post_type:post|by_id:12526,12074,12063,9784\"][/vc_column][/vc_row]","post_title":"Kennedy Space Center","post_link":"https://www.heyusa.com/nl/kennedy-space-center/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Kennedy Space Center\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/09/Kennedy-Space-Center-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1662559977:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"16","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Kennedy Space Center","%_yoast_wpseo_title%":"Kennedy Space Center in Florida %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Alles over de ruimtevaart vind je in het Kennedy Space Center in Florida. Tips voor het bezoeken van het Kennedy Space Center.","%_yoast_wpseo_linkdex%":"83","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"Florida 32899, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"28.5728722","%_wpgmp_metabox_longitude%":"-80.64898079999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"12858","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"65","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677014982","taxonomy=category":"Bezienswaardigheden","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":12854,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Antelope Canyon &#8211; tips voor je bezoek!","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Upper antelope Canyon\" width=\"300\" height=\"199\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/09/upper-antelope-canyon-300x199.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Antelope Canyon &#8211; tips voor je bezoek!</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Antelope Canyon, Arizona 86040, Verenigde Staten","location":{"lat":"36.8619103","state":"Arizona","country":"Verenigde Staten","lng":"-111.3743302","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/antelope-canyon/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Antelope Canyon in Arizona\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<strong>\u00c9\u00e9n van de mooiste natuurlijke bezienswaardigheden in Amerika is de Antelope Canyon. Beroemd vanwege de rode rotsen en vooral vanwege de prachtige lichtstralen in de canyon</strong>. De Antelope Canyon vind je vlakbij het dorpje <a href=\"https://www.heyusa.com/nl/bezienswaardigheden-page-arizona/\">Page</a> in Arizona en dien je onder begeleiding van een Navajo-gids te bezoeken. De Antelope Canyon bestaat uit verschillende canyons die kunt bezoeken, waarvan de Lower Antelope Canyon en de Upper Antelope Canyon de bekendste zijn. Het gebied ligt in het <a href=\"https://www.heyusa.com/nl/great-escapes/tribal-parken/\" target=\"_blank\" rel=\"noopener\">Navajo reservaat</a> in Arizona. Alles wat je moet weten voor een bezoek aan de Antelope Canyon![/vc_column_text][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"1/2\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Hey!USA Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Onze beste tip die we kunnen geven: Reserveer van tevoren! We hebben al vaak gehoord dat rondleidingen uitverkocht waren. Als je tijdens je rondreis maar \u00e9\u00e9n dag in dit gebied bent, mis je hierdoor een bezoek aan de Antelope Canyon.\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:100%20light%20regular%3A100%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612950540814{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Ontstaan Antelope Canyon\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">De Antelope Canyons zijn ontstaan door de grote krachten van de natuur. Miljoenen jaren van overstromingen en erosie. Met het water werd steen en puin meegesleurd waardoor de canyons beetje bij beetje werden uitgesleten. Daarnaast was ook de wind belangrijk voor het ontstaan van de canyons. Over het algemeen zijn dit zeer droge gebieden maar zelfs als het nu regent, zijn de canyons niet toegankelijk vanwege overstromingsgevaar.</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Lower Antelope Canyon\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"De minst bezochte Antelope Canyon\" font_size=\"55\" line_height=\"60\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"12845\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Tip 1:\" font_container=\"tag:div|font_size:30|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"10px\"][vc_custom_heading text=\"Upper Antelope Canyon bezoeken\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De meest populaire van de twee canyons om te bezoeken is de Upper Antelope Canyon. Deze is makkelijk toegankelijk vanaf de grond. In de Upper Antelope Canyon kun je al de prachtige foto's van lichtinval maken die kenbaar zijn voor de Antelope Canyon. De canyon is circa 200 meter lang en is goed te doen voor kinderen.\r\n<h3>Upper Antelope Canyon informatie:</h3>\r\n<ul>\r\n \t<li>Ongeveer 200 meter lang</li>\r\n \t<li>Beste periode: eind maart - begin oktober</li>\r\n \t<li>Tussen 10:00 uur en 13:00 uur maak je de mooiste foto's</li>\r\n \t<li>Meest populair</li>\r\n</ul>\r\n[/vc_column_text][ult_buttons btn_title=\"BESTEL TICKETS\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fpage-arizona-l108872%2Fupper-antelope-canyon-admission-ticket-and-guided-tour-t409801%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dupperantelopeantelopecanyon|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#000000\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Tip 2:\" font_container=\"tag:div|font_size:30|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"10px\"][vc_custom_heading text=\"Lower Antelope Canyon bezoeken\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De Lower Antelope Canyon ligt een stukje verder dan de Upper Canyon. Om hier in de canyon te komen, die je stalen trappen te beklimmen. De Lower Canyon wordt vanwege de afstand en het klimmen minder bezocht dan de Upper. Hoewel het iets meer klimmen is, is het wel geschikt om met kinderen te bezoeken. Met een rondleiding ben je ongeveer 1 uur en 15 minuten onderweg. De hele dag door kun je mooie foto's maken, maar de mooiste maak je tot laat in de ochtend.\r\n<h3>Lower Antelope Canyon informatie:</h3>\r\n<ul>\r\n \t<li>400 meter lang</li>\r\n \t<li>Beste periode: eind maart - begin oktober</li>\r\n \t<li>Laat in de ochtend maak je de mooiste foto's</li>\r\n \t<li>Moeilijker begaanbaar dan Upper Antelope Canyon</li>\r\n</ul>\r\n[/vc_column_text][ult_buttons btn_title=\"BESTEL TICKETS\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fpage-arizona-l108872%2Fpage-lower-antelope-canyon-walking-tour-with-navajo-guide-t408855%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dlowerantelopeantelopecanyon|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#000000\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Tip 3:\" font_container=\"tag:div|font_size:30|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"10px\"][vc_custom_heading text=\"Canyon X bezoeken\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Vlakbij de Lower Antelope Canyon ligt Canyon X. Bekend vanwege de iconische X die de vorm van de canyon weergeeft. De Upper en Lower zijn de meest bekende om te bezoeken, Canyon X is relatief nieuw. Hierdoor is de plek nog onontdekt en een stuk minder druk. Net als de andere twee canyons, dient ook deze met een <a href=\"https://www.getyourguide.com/page-arizona-l108872/antelope-canyon-entry-ticket-to-upper-lower-or-canyon-x-t385190/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=canyonxantelopecanyon\" target=\"_blank\" rel=\"noopener\">gids</a> bezocht te worden.\r\n<h3>Canyon X informatie:</h3>\r\n<ul>\r\n \t<li>1,5 uur durende tour</li>\r\n \t<li>Beste periode: eind maart - begin oktober</li>\r\n \t<li>Tot circa 14:00 uur maak je de mooiste foto's</li>\r\n</ul>\r\n[/vc_column_text][ult_buttons btn_title=\"BESTEL TICKETS\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fpage-arizona-l108872%2Fantelope-canyon-entry-ticket-to-upper-lower-or-canyon-x-t385190%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dcanyonxantelopecanyon|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#000000\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1664956694418{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Fotografie in de Antelope Canyon\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Handige tip voor de mooiste foto's in de Antelope Canyon\" font_container=\"tag:h3|font_size:30|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Foto's maken in de Antelope Canyon kan voor een amateur-fotograaf niet gemakkelijk zijn. Het is er namelijk donker, smal, lichtinval veranderd veel en je mag geen statief meebrengen. De Navajo-gidsen zijn super vriendelijk en behulpzaam. Ze kennen veel fotocamera's en zetten met plezier je instellingen op de perfecte stand! Met deze tips maak je de mooiste foto's:</p>\r\n<p style=\"text-align: center;\"><strong>Tip 1:</strong> Zet je camera op 'Manual', de automatische standen van je camera zullen geen geweldig resultaat opleveren.</p>\r\n<p style=\"text-align: center;\"><strong>Tip 2:</strong> Zet de exposure van je camera op een snelle stand. Afhankelijk van je camera minstens op 1/80 en het liefst op 1/120.</p>\r\n<p style=\"text-align: center;\"><strong>Tip 3:</strong> Zet de ISO-stand van je camera zo laag mogelijk. ISO-100 is al voldoende, speel tijdens je bezoek tot maximaal ISO-500.</p>\r\n<p style=\"text-align: center;\"><strong>Tip 4:</strong> Reis je in gezelschap of met je partner? Vraag dan of je de schouder mag gebruiken als statief. Hiermee voorkom je blurry foto's.</p>\r\n<p style=\"text-align: center;\"><strong>Tip 5:</strong> Onthoud dat het in de Antelope Canyon stoffig is, het verwisselen van lenzen is niet aan te raden ivm stof en zand.</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Meer foto's van de Antelope Canyon\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][thb_image_slider images=\"12847,12848,12849,12846,12845\"][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Meer lezen\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:5876,9996,9826,3208\"][/vc_column][/vc_row]","post_title":"Antelope Canyon &#8211; tips voor je bezoek!","post_link":"https://www.heyusa.com/nl/antelope-canyon/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Upper antelope Canyon\" width=\"300\" height=\"199\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/09/upper-antelope-canyon-300x199.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Natuur","post_tags":"Navajo, Oregon, Tribal Park","%_wpb_shortcodes_custom_css%":".vc_custom_1612950540814{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1664956694418{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}","%inline_featured_image%":"0","%_edit_last%":"1","%_edit_lock%":"1691238780:1","%_wpb_vc_js_status%":"true","%post-primary-category%":"32","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"12846","%_yoast_wpseo_focuskw%":"Antelope Canyon","%_yoast_wpseo_metadesc%":"Antelope Canyon in Arizona is een must om te bezoeken. Alles tips voor een bezoek aan de Lower Canyon, Upper Canyon en Canyon X.","%_yoast_wpseo_linkdex%":"73","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Lower Antelope Canyon \"]","%_wpgmp_location_address%":"Antelope Canyon, Arizona 86040, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Arizona","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"36.8619103","%_wpgmp_metabox_longitude%":"-111.3743302","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_primary_category%":"63","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1691190394","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Natuur","taxonomy=post_tag":"Navajo, Oregon, Tribal Park","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/parken.png"},"id":12842,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/parken.png","name":"Nationale Parken","id":"7","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"De &#8216;Naked Cowboy&#8217; op Times Square","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"naked cowboy\" width=\"300\" height=\"240\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/08/naked-cowboy-timessquare-300x240.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">De &#8216;Naked Cowboy&#8217; op Times Square</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Manhattan, New York 10036, Verenigde Staten","location":{"lat":"40.7579747","city":"New York City","state":"New York","country":"Verenigde Staten","lng":"-73.9855426","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/naked-cowboy-times-square/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"25px\"][vc_custom_heading text=\"Naked Cowboy op Times Square in New York\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\"><strong>Hij stond al op Times Square lang voordat Elmo, Spiderman en Olaf de sneeuwpop met elkaar op de vuist gingen\u00a0voor de beste plek. Of\u00a0toeristen uitscholden voor rotte vis omdat ze geen fooi gaven. Sterker\u00a0nog, je kunt stellen dat\u00a0Robert John Burck live\u00a0entertainment op Times Square heeft uitgevonden. Over wie wij het hebben? <em>The Times Square Naked Cowboy natuurlijk!</em></strong></span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Naked Cowboy\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Een attractie op Times Square\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"12806\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Een naakte cowboy\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Of het nu vriest of de mussen vallen van het dak, the Naked Cowboy is bijna dagelijks te vinden op het middelpunt van <a href=\"https://www.heyusa.com/nl/new-york/times-square/\">Times Square</a>. The Naked Cowboy, geboren in Cincinnati, Ohio begon zijn jonge carri\u00e8re als fotomodel. Hij verscheen een paar seconden in de hitserie <a href=\"https://www.imdb.com/title/tt0096542/?ref_=nv_sr_srsg_0\" target=\"_blank\" rel=\"noopener\">Baywatch</a> en kreeg een paar shoots voor de Playgirl, maar verder dan dat kwam hij niet. Totdat hij in 1998, na drie jaar zonder succes en amper een inkomen besloot om in enkel zijn ondergoed, cowboy hoed en een gitaar in <a href=\"https://www.heyusa.com/nl/los-angeles/venice/\">Venice Beach</a> op te treden. Zijn dagopbrengst: $100!\r\n\r\nRobert John lanceerde zichzelf als The Naked Cowboy en met succes! TV zenders uit Los Angeles hoorden over dit nieuwe fenomeen en filmden deze naakte cowboy in Venice Beach. In no-time was hij een celebrity in Californi\u00eb.\r\n\r\n<span style=\"font-weight: 400;\">\u00a0</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Hoe werd Robert John de 'Naked Cowboy' op Times Square?\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Voordat hij definitief naar New York vertrok, toerde hij als nieuw fenomeen en enkel in zijn onderbroek naar Las Vegas, Nashville, New Orleans en weer terug. Zijn beste vriend grapte dat hij dan ook maar eens naar New York moest gaan en zo belandde The Naked Cowboy midden op Times Square...</span>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Meer foto's van de Naked Cowboy\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][thb_image_slider images=\"12807,12806,12805,12804\"][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:1571,968,910,1784\"][/vc_column][/vc_row]","post_title":"De &#8216;Naked Cowboy&#8217; op Times Square","post_link":"https://www.heyusa.com/nl/naked-cowboy-times-square/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"naked cowboy\" width=\"300\" height=\"240\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/08/naked-cowboy-timessquare-300x240.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1661845789:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"14","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"12807","%_yoast_wpseo_focuskw%":"Naked Cowboy","%_yoast_wpseo_title%":"%%title%% in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"De Naked Cowboy op Times Square is een ware attractie geworden. Wie kent hem inmiddels niet? Het verhaal achter de Naked Cowboy.","%_yoast_wpseo_linkdex%":"79","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"Manhattan, New York 10036, Verenigde Staten","%_wpgmp_location_city%":"New York City","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7579747","%_wpgmp_metabox_longitude%":"-73.9855426","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677014994","taxonomy=category":"Bezienswaardigheden New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":12801,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Sundaes &#038; Cones &#8211; New York","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sundaes and Cones\" width=\"300\" height=\"225\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/08/sundaes-cones-300x225.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Sundaes &#038; Cones &#8211; New York</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"95 E 10th St, New York, NY 10003, Verenigde Staten","location":{"lat":"40.7309957","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.98940619999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/sundaes-cones-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\" css=\".vc_custom_1661284757584{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/11/background-dc-scaled.gif?id=2612) !important;}\"][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_column_text][/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Sundaes and Cones- New York\" font_container=\"tag:h2|font_size:40|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_row_inner][vc_column_inner width=\"1/2\"][bsf-info-box icon=\"Defaults-map-marker\" icon_size=\"32\" icon_color=\"#282828\" title=\"95 East 10th Street\" heading_tag=\"span\"][/bsf-info-box][/vc_column_inner][vc_column_inner width=\"1/2\"][bsf-info-box icon=\"Defaults-subway\" icon_size=\"32\" icon_color=\"#282828\" title=\"Astor Pl | Lijn: 6\" heading_tag=\"span\"][/bsf-info-box][/vc_column_inner][/vc_row_inner][vc_custom_heading text=\"Wereldse ijssmaken\" font_container=\"tag:h3|font_size:30|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<strong>Vraag aan een New Yorker waar hij het liefst een ijsje eet en de kans is groot dat je naar <a href=\"http://sundaescones.com/\" target=\"_blank\" rel=\"noopener\">Sundaes and Scones</a> wordt gestuurd. En dat zegt iets aangezien er heel veel ijssalons in de stad zitten. Bij deze fijne no nonsense plek in East Village kun je afkoelen en tegelijkertijd je smaakpapillen trakteren op wereldse smaken. </strong>[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1661284218827{background-color: #f2f2f2 !important;}\"][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Tasting is believing\" font_container=\"tag:h2|font_size:25|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De ijssalon is licht, modern en basic ingericht. Lekker puur en simpel. Hier gaat het niet per se om een hippe presentatie, maar om al het lekkers dat uit de keuken komt. Zoals de naam al verklapt kun je hier terecht voor ijs in een hoorntje, maar ook frozen yoghurt, geweldige taarten of gewoon een (ijs)koffie of thee (to go).\r\nAlles is huisgemaakt en dat proef je. Hun slogan luidt dan ook \u2018tasting is believing\u2019.[/vc_column_text][fullwidth_row content_width=\"90%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Exotische smaken\" font_container=\"tag:h3|font_size:25|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Als je voor de grote bakken ijs staat en al die bijzondere smaken ziet (zelfs ma\u00efs zit erbij) is het moeilijk kiezen. Aanrader: het door Azi\u00eb ge\u00efnspireerde ijs met zwart sesamzaad, wasabi en gember. Heerlijk verfrissend op een dag dat je wegsmelt in the city. Liever aardbei, vanille of chocola? Ook deze oude, vertrouwde smaken worden met liefde gemaakt. Je kunt binnen zitten, maar het terras aan de straat (met schaduw van\r\nenkele bomen) nodigt uit om fijn buiten te zitten en mensen te kijken in dit o z\u00f3 fijne buurtje.[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"80%\"][ultimate_heading main_heading=\"Meer Hotspots in New York:\" main_heading_color=\"#c59c4d\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:65px;\"][/ultimate_heading][vc_empty_space height=\"25px\"][thb_postgrid style=\"style4\" columns=\"4\" source=\"size:4|post_type:post,page|by_id:12425,8926,8906,12475\"][/vc_column][/vc_row]","post_title":"Sundaes &#038; Cones &#8211; New York","post_link":"https://www.heyusa.com/nl/sundaes-cones-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sundaes and Cones\" width=\"300\" height=\"225\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/08/sundaes-cones-300x225.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Hotspots New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1661284757584{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/11/background-dc-scaled.gif?id=2612) !important;}.vc_custom_1661284218827{background-color: #f2f2f2 !important;}","%_edit_lock%":"1661836675:2","%_edit_last%":"1","%_hide_featured%":null,"%_wpgmp_location_address%":"95 E 10th St, New York, NY 10003, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7309957","%_wpgmp_metabox_longitude%":"-73.98940619999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"15\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%inline_featured_image%":"0","%_yoast_wpseo_primary_category%":"7","%_thumbnail_id%":"12766","%_yoast_wpseo_content_score%":"90","%_yoast_indexnow_last_ping%":"1677014999","%_yoast_wpseo_metadesc%":"Op zoek naar een ijssalon in New York met exotische smaken? Ga dan naar Sundaes and Cones voor de meest uiteenlopende ijssoorten.","%_yoast_wpseo_focuskw%":"Sundaes and Cones","%_yoast_wpseo_linkdex%":"62","%post_via%":[{"title":"\u00a9 Sundaes and Cones","post_source_url":"http://sundaescones.com"}],"%_wp_old_slug%":"sarabeths-new-york","taxonomy=category":"Hotspots New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/food.png"},"id":12764,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/food.png","name":"Food","id":"15","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"BLVD Harlem","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"BLVD Harlem\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/08/blvd-harlem-300x200.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">BLVD Harlem</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"2149 Frederick Douglass Blvd, New York, NY 10026, Verenigde Staten","location":{"lat":"40.8043626","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.95575149999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/blvd-harlem/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\" css=\".vc_custom_1661284757584{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/11/background-dc-scaled.gif?id=2612) !important;}\"][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_column_text][/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"BLVD Harlem - New York\" font_container=\"tag:h2|font_size:40|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_row_inner][vc_column_inner width=\"1/2\"][bsf-info-box icon=\"Defaults-map-marker\" icon_size=\"32\" icon_color=\"#282828\" title=\"2149 Frederick Douglass Boulevard\" heading_tag=\"span\"][/bsf-info-box][/vc_column_inner][vc_column_inner width=\"1/2\"][bsf-info-box icon=\"Defaults-subway\" icon_size=\"32\" icon_color=\"#282828\" title=\"Cathedral Pkwy | Lijn: A | C | B\" heading_tag=\"span\"][/bsf-info-box][/vc_column_inner][/vc_row_inner][vc_custom_heading text=\"24 uur per dag ontbijten in New York?\" font_container=\"tag:h3|font_size:30|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<strong>In New York kun je altijd 24 uur per dag ontbijten. Ook in Harlem! Maar op zondag gebeurd er iets unieks in de stad: New Yorkers gaan brunchen. BLVD Bistro in Harlem, is een hotspot voor \u00e9chte New Yorkers. De locals van dit hippe deel van Harlem (want het Noordelijk deel is nog altijd best wel wat ruig) gaan hier graag brunchen. Bestel zeker de Banana Pecan Pancakes en een BLVD Mary (Bloody Mary), want ja, New Yorkers drinken cocktails bij hun ontbijt ;)</strong>[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1661284218827{background-color: #f2f2f2 !important;}\"][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"BLVD Harlem - geschikt voor de hele dag\" font_container=\"tag:h2|font_size:25|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Niet enkel de brunch is de moeite waard, de Amerikaanse keuken komt hier helemaal tot z'n recht. Zoals de Pulled Pork sandwich met coleslaw, alleen al daarvoor zouden wij een vliegticket boeken en naar NYC reizen.[/vc_column_text][fullwidth_row content_width=\"90%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Warme familiesfeer\" font_container=\"tag:h3|font_size:25|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<a href=\"https://www.boulevardbistrony.com/\" target=\"_blank\" rel=\"noopener\">BLVD bistro</a> is een echte familiebusiness. Eigenaar Carlos focust zich op het eten, iets waar hij al sinds zijn 6e mee bezig is. Ook de menukaart en de muziek komen uit zijn handen. Zijn vrouw Markisha focust zich op de dagelijkse business en alles wat daar bij komt kijken.[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][thb_image_slider thb_equal_height=\"true\" images=\"12761,12760,12759,12758\"][fullwidth_row content_width=\"90%\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"80%\"][ultimate_heading main_heading=\"Meer Hotspots in New York:\" main_heading_color=\"#c59c4d\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:65px;\"][/ultimate_heading][vc_empty_space height=\"25px\"][thb_postgrid style=\"style4\" columns=\"4\" source=\"size:4|post_type:post,page|by_id:12425,8926,8906,12475\"][/vc_column][/vc_row]","post_title":"BLVD Harlem","post_link":"https://www.heyusa.com/nl/blvd-harlem/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"BLVD Harlem\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/08/blvd-harlem-300x200.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Hotspots New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1661284757584{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/11/background-dc-scaled.gif?id=2612) !important;}.vc_custom_1661284218827{background-color: #f2f2f2 !important;}","%_edit_lock%":"1661422649:2","%_edit_last%":"1","%_hide_featured%":null,"%_wpgmp_location_address%":"2149 Frederick Douglass Blvd, New York, NY 10026, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.8043626","%_wpgmp_metabox_longitude%":"-73.95575149999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"15\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%inline_featured_image%":"0","%_yoast_wpseo_primary_category%":"7","%_thumbnail_id%":"12762","%_yoast_wpseo_content_score%":"90","%_yoast_indexnow_last_ping%":"1677015001","%_yoast_wpseo_metadesc%":"Op zoek naar een plek in New York waar je de hele dag kunt ontbijten? Ga dan naar BLVD Harlem in New York voor een all-day-brunch","%_yoast_wpseo_focuskw%":"BLVD Harlem","%_yoast_wpseo_linkdex%":"72","%post_via%":[{"title":"\u00a9 BLVD Bistro","post_source_url":"https://www.boulevardbistrony.com"}],"%_wp_old_slug%":"sarabeths-new-york","taxonomy=category":"Hotspots New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/food.png"},"id":12757,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/food.png","name":"Food","id":"15","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Marta Manhattan &#8211; New York","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Marta\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/08/pizzeria-marta-nyc-3-300x200.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Marta Manhattan &#8211; New York</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"29 E 29th St, New York, NY 10016, Verenigde Staten","location":{"lat":"40.7444764","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.9845825","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/pizzeria-marta-manhattan-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\" css=\".vc_custom_1661284757584{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/11/background-dc-scaled.gif?id=2612) !important;}\"][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_column_text][/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Pizzeria Marta Manhattan in New York\" font_container=\"tag:h2|font_size:40|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_row_inner][vc_column_inner width=\"1/2\"][bsf-info-box icon=\"Defaults-map-marker\" icon_size=\"32\" icon_color=\"#282828\" title=\"29 East 29th Street\" heading_tag=\"span\"][/bsf-info-box][/vc_column_inner][vc_column_inner width=\"1/2\"][bsf-info-box icon=\"Defaults-subway\" icon_size=\"32\" icon_color=\"#282828\" title=\"28 Street | Lijn: 6\" heading_tag=\"span\"][/bsf-info-box][/vc_column_inner][/vc_row_inner][vc_custom_heading text=\"Een van de beste pizza's in NYC?\" font_container=\"tag:h3|font_size:30|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<strong>In een stad waar je bijna op elke hoek van de straat pizza kunt eten, is de keuze niet\u00a0gemakkelijk. Want waar krijg je nu \u00e9cht goede pizza? <a href=\"https://www.martamanhattan.com/\" target=\"_blank\" rel=\"noopener\">Marta Manhattan</a> springt er\u00a0tussenuit met een frisse kijk op de klassieke pizza. Bekroond met een jubelende recensie van\u00a0The New York Times en toch betaalbaar. Een absolute aanrader voor krokante, dunne pizza\u2019s! Deze pizzeria ligt op een steenworp afstand van Madison Square Park (waar je meteen een foto van het Flatiron Building kunt maken). Reserveren is een must!</strong>[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1661284218827{background-color: #f2f2f2 !important;}\"][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Pizza Shack\" font_container=\"tag:h2|font_size:25|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Oprichter en groot aandeelhouder van ShakeShack \u201cDanny\u00a0Meyer\u201d<span class=\"Apple-converted-space\">\u00a0 </span>vernieuwt al meer dan 30 jaar de Amerikaanse keuken. Na hamburgers kreeg hij pizza in het vizier. En voila Marta was geboren.[/vc_column_text][fullwidth_row content_width=\"90%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Pizza's van Marta\" font_container=\"tag:h3|font_size:25|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De pizza's van Marta zijn ge\u00efnspireerd op de rustieke keuken van Rome. De pizza's hebben een dunne en knapperige korst en zijn belegd zeevruchten of verse groentes. Er zijn opties voor vegetari\u00ebrs en veganisten bij Marta. Ook de wijn en bier kaart van Marta is een goede reden om hier een keer te gaan eten. Onze favoriet? De Margherita Pizza, heerlijk krokant met goede mozzarella.[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][thb_image_slider thb_equal_height=\"true\" images=\"12753,12752,12751,12749\"][fullwidth_row content_width=\"90%\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"80%\"][ultimate_heading main_heading=\"Meer Hotspots in New York:\" main_heading_color=\"#c59c4d\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:65px;\"][/ultimate_heading][vc_empty_space height=\"25px\"][thb_postgrid style=\"style4\" columns=\"4\" source=\"size:4|post_type:post,page|by_id:12425,8926,8906,12475\"][/vc_column][/vc_row]","post_title":"Marta Manhattan &#8211; New York","post_link":"https://www.heyusa.com/nl/pizzeria-marta-manhattan-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Marta\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/08/pizzeria-marta-nyc-3-300x200.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Hotspots New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1661284757584{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/11/background-dc-scaled.gif?id=2612) !important;}.vc_custom_1661284218827{background-color: #f2f2f2 !important;}","%_edit_lock%":"1661422799:2","%_edit_last%":"1","%_hide_featured%":null,"%_wpgmp_location_address%":"29 E 29th St, New York, NY 10016, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7444764","%_wpgmp_metabox_longitude%":"-73.9845825","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"15\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%inline_featured_image%":"0","%_yoast_wpseo_primary_category%":"7","%_thumbnail_id%":"12750","%_yoast_wpseo_content_score%":"90","%_yoast_indexnow_last_ping%":"1677015002","%_yoast_wpseo_metadesc%":"Op zoek naar een goede pizza in New York, maar geen idee waar je naar toe moet? Ga dan naar Marta Manhattan voor de beste pizza.","%_yoast_wpseo_focuskw%":"Marta Manhattan","%_yoast_wpseo_linkdex%":"61","%post_via%":[{"title":"\u00a9 Marta","post_source_url":"https://www.martamanhattan.com"}],"%_wp_old_slug%":"sarabeths-new-york","taxonomy=category":"Hotspots New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/food.png"},"id":12748,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/food.png","name":"Food","id":"15","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Partners Coffee &#8211; New York","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Partnes Coffee\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/08/partnercoffee-300x200.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Partners Coffee &#8211; New York</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"125 N 6th St, Brooklyn, NY 11249, Verenigde Staten","location":{"lat":"40.71801069999999","state":"New York","country":"Verenigde Staten","lng":"-73.9591725","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/partners-coffee-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\" css=\".vc_custom_1661284757584{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/11/background-dc-scaled.gif?id=2612) !important;}\"][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_column_text][/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Partners Coffee New York\" font_container=\"tag:h2|font_size:40|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_row_inner][vc_column_inner width=\"1/2\"][bsf-info-box icon=\"Defaults-map-marker\" icon_size=\"32\" icon_color=\"#282828\" title=\"125 N 6th Street (Williamsburg)\" heading_tag=\"span\"][/bsf-info-box][/vc_column_inner][vc_column_inner width=\"1/2\"][bsf-info-box icon=\"Defaults-subway\" icon_size=\"32\" icon_color=\"#282828\" title=\"Bedford Avenue | Lijn: L\" heading_tag=\"span\"][/bsf-info-box][/vc_column_inner][/vc_row_inner][vc_custom_heading text=\"Persoonlijke koffie favoriet in NYC\" font_container=\"tag:h3|font_size:30|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<strong>Een persoonlijke koffie-favoriet van Hey!USA ligt in <a href=\"https://www.heyusa.com/nl/new-york/williamsburg/\">Williamsburg</a>, Brooklyn. Bij <a href=\"https://www.partnerscoffee.com/\" target=\"_blank\" rel=\"noopener\">Partners Coffee</a> (voorheen beter bekend als Toby\u2019s Estate) kun je terecht voor heerlijke koffie van enorm goeie barista\u2019s, maar buiten dat is het gewoon een plek waar je wilt zijn. De sfeer is er fantastisch. Het zit altijd vol met mensen van allerlei leeftijden. Vooral hipsters, dat moeten we toegeven, maar dat is niet gek als je naar het geweldige interieur kijkt.</strong>[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1661284218827{background-color: #f2f2f2 !important;}\"][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Australische koffie\" font_container=\"tag:h2|font_size:25|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Ondanks dat het dus retehip is, hangt er een fijne no nonsense sfeer, waardoor iedereen zich welkom voelt. Misschien komt het wel doordat de originele oprichter, Toby Smith, een Australi\u00ebr is. Naast koffie kun je er ook ander lekkers krijgen, zoals muffins en brownies. De kunst van een goed bakkie zetten leren? Je kunt er verschillende workshops volgen.[/vc_column_text][fullwidth_row content_width=\"90%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Leuk detail\" font_container=\"tag:h3|font_size:25|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Je kunt ter plekke zien hoe de koffiebonen worden gemalen. Partners Coffee heeft ook een filiaal in Bushwick (8 Wilson Avenue) en in Long Island City (26-25 Jackson Avenue in Queens). Wil je liever h\u00e9t eiland niet verlaten (daarmee bedoelen we natuurlijk Manhattan)? Dan kun je ook daar een hippe koffie gaan drinken bij verschillende vestigingen. Ze zitten onder andere in West Village, Midtown West en <a href=\"https://www.heyusa.com/nl/urbanspace-new-york/\">Urbanspace Vanderbilt</a>.[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][thb_image_slider thb_equal_height=\"true\" images=\"12745,12744,12743\"][fullwidth_row content_width=\"90%\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"80%\"][ultimate_heading main_heading=\"Meer Hotspots in New York:\" main_heading_color=\"#c59c4d\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:65px;\"][/ultimate_heading][vc_empty_space height=\"25px\"][thb_postgrid style=\"style4\" columns=\"4\" source=\"size:4|post_type:post,page|by_id:12425,8926,8906,12475\"][/vc_column][/vc_row]","post_title":"Partners Coffee &#8211; New York","post_link":"https://www.heyusa.com/nl/partners-coffee-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Partnes Coffee\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/08/partnercoffee-300x200.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Hotspots New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1661284757584{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/11/background-dc-scaled.gif?id=2612) !important;}.vc_custom_1661284218827{background-color: #f2f2f2 !important;}","%_edit_lock%":"1661423213:2","%_edit_last%":"1","%_hide_featured%":null,"%_wpgmp_location_address%":"125 N 6th St, Brooklyn, NY 11249, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.71801069999999","%_wpgmp_metabox_longitude%":"-73.9591725","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"15\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%inline_featured_image%":"0","%_yoast_wpseo_primary_category%":"7","%_thumbnail_id%":"12746","%_yoast_wpseo_content_score%":"90","%_yoast_indexnow_last_ping%":"1677015004","%_yoast_wpseo_metadesc%":"Een favoriete plek in New York om koffie te halen is Partners Coffee. Met vestigingen door heel New York hoef je niet op zoek naar goede koffie.","%_yoast_wpseo_focuskw%":"Partners Coffee","%_yoast_wpseo_linkdex%":"73","%post_via%":[{"title":"\u00a9 Partners Coffee","post_source_url":"https://www.partnerscoffee.com"}],"%_wp_old_slug%":"sarabeths-new-york","taxonomy=category":"Hotspots New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/food.png"},"id":12742,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/food.png","name":"Food","id":"15","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Sarabeths &#8211; New York","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sarabeths\" width=\"300\" height=\"225\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/08/sarabeths-300x225.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Sarabeths &#8211; New York</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"40 Central Park S, New York, NY 10019, Verenigde Staten","location":{"lat":"40.76530889999999","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.9757501","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/sarabeths-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\" css=\".vc_custom_1661284757584{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/11/background-dc-scaled.gif?id=2612) !important;}\"][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_column_text][/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Sarabeths New York\" font_container=\"tag:h2|font_size:40|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_row_inner][vc_column_inner width=\"1/2\"][bsf-info-box icon=\"Defaults-map-marker\" icon_size=\"32\" icon_color=\"#282828\" title=\"40 Central Park South\" heading_tag=\"span\"][/bsf-info-box][/vc_column_inner][vc_column_inner width=\"1/2\"][bsf-info-box icon=\"Defaults-subway\" icon_size=\"32\" icon_color=\"#282828\" title=\"5 Av / 59 St | Lijn: N | R | W\" heading_tag=\"span\"][/bsf-info-box][/vc_column_inner][/vc_row_inner][vc_custom_heading text=\"Brunchen in New York\" font_container=\"tag:h3|font_size:30|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<strong>Als je op zoek bent naar een chique restaurant om te brunchen, dan ben je bij Sarabeths aan het juiste adres. Het restaurant serveert elke dag ontbijt, lunch en avondeten, maar staat vooral bekend om de brunch. New Yorkers doen nu eenmaal niks liever in het weekend dan <a href=\"http://www.nwyrk.com/hotspots/blvd-harlem/\">uitgebreid brunchen met Mimosa\u2019s en Bloody Mary\u2019s</a>.</strong>[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1661284218827{background-color: #f2f2f2 !important;}\"][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Geduld is een schone zaak\" font_container=\"tag:h2|font_size:25|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Dat het restaurant geliefd is bij zowel locals als toeristen, blijkt uit de lange wachttijden. Je zult een beetje geduld en geluk moeten hebben om een tafel te kunnen bemachtigen, maar het vriendelijke personeel, de goede service en de menukaart zijn het wachten meer dan waard.[/vc_column_text][fullwidth_row content_width=\"90%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Brunchen bij Sarabeths en dan wandelen in Central Park\" font_container=\"tag:h3|font_size:25|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Er kan gekozen worden uit verschillende soorten granola en havermout, fruit salades of een zoet ontbijt. De zoete ontbijtjes worden bij Sarabeths het meest gewaardeerd: Fat and fluffy French toast, apple-cinnamon French toast, almond crusted French toast of een stapel pannenkoeken met fruit. <a href=\"https://sarabethsrestaurants.com/\" target=\"_blank\" rel=\"noopener\">Sarabeths</a> denkt niet alleen aan de zoetekauw, maar biedt gelukkig ook verschillende soorten eiergerechten, zoals de klassieke eggs benedict, scrambled eggs of omelet op elke mogelijke manier die je kunt bedenken.\r\nDe porties zijn gigantisch: perfect om jezelf mee op te warmen op een koude winterdag in New York. De calorie\u00ebn kunnen vervolgens verbrand worden op de ijsbaan in <a href=\"https://www.heyusa.com/nl/central-park-new-york-city/\">Central Park</a>.\r\n<h2></h2>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][thb_image_slider thb_equal_height=\"true\" images=\"12717,12716,12715\"][fullwidth_row content_width=\"90%\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"80%\"][ultimate_heading main_heading=\"Meer Hotspots in New York:\" main_heading_color=\"#c59c4d\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:65px;\"][/ultimate_heading][vc_empty_space height=\"25px\"][thb_postgrid style=\"style4\" columns=\"4\" source=\"size:4|post_type:post,page|by_id:12425,8926,8906,12475\"][/vc_column][/vc_row]","post_title":"Sarabeths &#8211; New York","post_link":"https://www.heyusa.com/nl/sarabeths-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sarabeths\" width=\"300\" height=\"225\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/08/sarabeths-300x225.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Hotspots New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1661284757584{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/11/background-dc-scaled.gif?id=2612) !important;}.vc_custom_1661284218827{background-color: #f2f2f2 !important;}","%_edit_lock%":"1661423213:2","%_edit_last%":"1","%_hide_featured%":null,"%_wpgmp_location_address%":"40 Central Park S, New York, NY 10019, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.76530889999999","%_wpgmp_metabox_longitude%":"-73.9757501","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"15\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"La Colombe\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%inline_featured_image%":"0","%_yoast_wpseo_primary_category%":"7","%_thumbnail_id%":"12718","%_yoast_wpseo_content_score%":"90","%_yoast_indexnow_last_ping%":"1677015006","%_yoast_wpseo_metadesc%":"Op zoek naar leuke plek om te brunchen in New York? Bezoek dan Sarabeths in New York voor de ultieme brunch.","%_yoast_wpseo_focuskw%":"Sarabeths","%_yoast_wpseo_linkdex%":"82","%post_via%":[{"title":"\u00a9 Siobhan Gunner & Sarabeths","post_source_url":"https://sarabethsrestaurants.com"}],"%_wp_old_slug%":"sarabeths-new-york","taxonomy=category":"Hotspots New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/food.png"},"id":12735,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/food.png","name":"Food","id":"15","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Max Brenner &#8211; New York","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Max Brenner\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/08/max-brenner-4-300x200.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Max Brenner &#8211; New York</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"841 Broadway, New York, NY 10003, Verenigde Staten","location":{"lat":"40.73432269999999","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.991186","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/max-brenner-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\" css=\".vc_custom_1661284757584{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/11/background-dc-scaled.gif?id=2612) !important;}\"][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Max Brenner New York\" font_container=\"tag:h2|font_size:40|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_row_inner][vc_column_inner width=\"1/2\"][bsf-info-box icon=\"Defaults-map-marker\" icon_size=\"32\" icon_color=\"#282828\" title=\"841 Broadway\" heading_tag=\"span\"][/bsf-info-box][/vc_column_inner][vc_column_inner width=\"1/2\"][bsf-info-box icon=\"Defaults-subway\" icon_size=\"32\" icon_color=\"#282828\" title=\"14 St - Union Square | Lijn: 4 | 5 | 6 | L | N | Q | R | W\" heading_tag=\"span\"][/bsf-info-box][/vc_column_inner][/vc_row_inner][vc_custom_heading text=\"Expert op chocolade gebied\" font_container=\"tag:h3|font_size:30|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<strong>Dichtbij Union Square ligt een begrip op chocoladegebied: Max Brenner. Deze oase van chocolade heb je nog nooit eerder gezien. Overal waar je kijkt is\u00a0chocolade. Je kunt er chocolade kopen, maar vooral ook ter plekke eten in de chocolade bar. Volgens <a href=\"https://maxbrenner.com/\" target=\"_blank\" rel=\"noopener\">Max Brenner</a> zelf is de chocolade zo verslavend, dat ze\u00a0zelfs chocolade shots verkopen.</strong>[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1661284218827{background-color: #f2f2f2 !important;}\"][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Ilegale chocolade ;)\" font_container=\"tag:h2|font_size:25|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Probeer eens een \u2018<em>Classic Chocolate Martini</em>\u2019 van melk en witte chocolade, absolut vanilla, cacao cr\u00e8me geserveerd met een in chocolade gedoopte aardbei... of de \u2018<em>illegale chocolade chocolade chocolade</em>\r\n<em>pannenkoeken</em>\u2019 met 70% pure chocolade, room,\u00a0melkchocolade, pecannoten schaafsel en\u00a0gecaramelliseerde bananen. Of de enige \u00e9chte chocolade pizza! Ja je lees het goed, een pizza met chocolade en marshmallows.[/vc_column_text][fullwidth_row content_width=\"90%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Bryant Park Winter Village\" font_container=\"tag:h3|font_size:25|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Max Brenner heeft ook regelmatig een popup store in de \u2018Winter Village\u2019 van <a href=\"https://www.heyusa.com/nl/bryant-park-new-york-city/\">Bryant Park</a>! Probeer daar zeker de \u2018<em>Dikke Italiaanse warme chocolademelk</em>\u2019 yummie![/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][thb_image_slider thb_equal_height=\"true\" images=\"12726,12725,12723,12722\"][fullwidth_row content_width=\"90%\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"80%\"][ultimate_heading main_heading=\"Meer Hotspots in New York:\" main_heading_color=\"#c59c4d\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:65px;\"][/ultimate_heading][vc_empty_space height=\"25px\"][thb_postgrid style=\"style4\" columns=\"4\" source=\"size:4|post_type:post,page|by_id:12425,8926,8906,12475\"][/vc_column][/vc_row]","post_title":"Max Brenner &#8211; New York","post_link":"https://www.heyusa.com/nl/max-brenner-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Max Brenner\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/08/max-brenner-4-300x200.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Hotspots New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1661284757584{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/11/background-dc-scaled.gif?id=2612) !important;}.vc_custom_1661284218827{background-color: #f2f2f2 !important;}","%_edit_lock%":"1661423741:2","%_edit_last%":"1","%_hide_featured%":null,"%_wpgmp_location_address%":"841 Broadway, New York, NY 10003, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.73432269999999","%_wpgmp_metabox_longitude%":"-73.991186","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"15\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%inline_featured_image%":"0","%_yoast_wpseo_primary_category%":"7","%_thumbnail_id%":"12724","%_yoast_wpseo_content_score%":"90","%_yoast_indexnow_last_ping%":"1677015008","%_yoast_wpseo_metadesc%":"De chocolade hotspots in New York is Max Brenner. Overal waar je kijkt is chocolade die je natuurlijk kunt kopen, maar ook kunt proeven","%_yoast_wpseo_focuskw%":"Max Brenner","%_yoast_wpseo_linkdex%":"68","%post_via%":[{"title":"Max Brenner","post_source_url":"https://maxbrenner.com/"}],"taxonomy=category":"Hotspots New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/food.png"},"id":12713,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/food.png","name":"Food","id":"15","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Area 15 Las Vegas","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Area 15\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/08/area-15-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Area 15 Las Vegas</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"3215 S Rancho Dr, Las Vegas, NV 89102, Verenigde Staten","location":{"lat":"36.1318636","city":"Las Vegas","state":"Nevada","country":"Verenigde Staten","lng":"-115.1816039","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/area-15-las-vegas/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Area 15 Las Vegas\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]<strong>Area 15 in Las Vegas, een nog redelijk onontdekte bezienswaardigheid. Wat het precies is, is lastig te defini\u00ebren. In een enorm hal vind je verschillende kunstinstallaties, VR ervaringen, winkelervaringen, evenementen, bars en restaurants. Kortom een mix van activiteiten en bezienswaardigheden waardoor Area 15 zich lastig laat defini\u00ebren.\u00a0 Het beste is denk ik gewoon ondergaan wat je tegenkomt in Area 15 en je onder te laten dompelen in alle toffe activiteiten.</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"3215 South Rancho Dr Las Vegas\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek je tickets\" btn_link=\"url:https%3A%2F%2Farea15.com%2F|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Immersieve ervaring bij Area 15\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Area 15 staat bol van de immersieve ervaringen die je op kunt doen. Via VR, zintuigelijke ervaringen, zombiejachten of een zipline race heb je de mogelijkheid om nieuwe ervaringen op te doen. Area 15 is gratis toegankelijk, er dient echter wel een <a href=\"https://area15.com/experiences/it-begins/\" target=\"_blank\" rel=\"noopener\">Entry Pas</a>s online 'gekocht' te worden. Wil je echt dingen gaan ervaren? Dan kun je een <a href=\"https://area15.com/experiences/pass/\" target=\"_blank\" rel=\"noopener\">Experience Pass</a> aanschaffen, deze kun je kopen vanaf $39. Je kunt ook losse tickets kopen voor de attracties. Area 15 is perfect op een regenachtige dag of juist een hele warme dag! Area 15 bevindt zich ten noorden van <a href=\"https://www.heyusa.com/nl/las-vegas/the-strip-las-vegas/\">The Strip</a> en is het best bereikbaar per auto of taxi/uber.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Area 15\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"De bijzondere ervaring begint buiten al\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:40px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_line_height=\"desktop:45px;\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"12590\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen in Area 15\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"12591\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Zipline\" heading_tag=\"h3\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Stap in \"roller glider' die lijkt op een zipline die dwars door de hal gaat. Je krijgt een tour door de lucht door het pand in de Haley's Comet. De kosten voor een ritje in de Haley Comet zijn $18.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"12592\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Bars &amp; Restaurants\" heading_tag=\"h3\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]In Area 15 bevinden zich verschillende bars en restaurants. Natuurlijk geen saaie mogelijkheden om wat te eten, maar gerechten die passen bij de uitstraling van Area 15.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"12593\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Kunstinstallaties\" heading_tag=\"h3\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]In Area 15 staan tal van kunstinstallaties die vaak interactief zien. Denk aan ervaringen met een VR bril, golfen, Wink World of de surrealistische wereld van Meow Wolf. Stuk voor stuk attracties of bezienswaardigheden die je niet vaak ziet en waarbij je je vooral moeten laten onderdompelen. Per attractie dien je een eigen ticket te kopen.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Bijzondere ervaringen in Area 15\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Laat je onderdompelen\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:40px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_line_height=\"desktop:45px;\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"12594\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Ook leuk om te doen in Las Vegas\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][thb_postgrid columns=\"4\" source=\"post_type:post|by_id:11787,11542,11382,10505\"][/vc_column][/vc_row]","post_title":"Area 15 Las Vegas","post_link":"https://www.heyusa.com/nl/area-15-las-vegas/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Area 15\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/08/area-15-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Las Vegas","post_tags":"Nevada","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%inline_featured_image%":"0","%_edit_lock%":"1669214166:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Area 15 \"]","%_yoast_wpseo_focuskw%":"Area 15 Las Vegas","%_yoast_wpseo_metadesc%":"In het Natural History Museum in Los Angeles vind je alles over natuur en historie. Tips voor je bezoek aan het Natural History Museum in LA","%_yoast_wpseo_linkdex%":"75","%_wpgmp_location_address%":"3215 S Rancho Dr, Las Vegas, NV 89102, Verenigde Staten","%_wpgmp_location_city%":"Las Vegas","%_wpgmp_location_state%":"Nevada","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"36.1318636","%_wpgmp_metabox_longitude%":"-115.1816039","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"54","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_thumbnail_id%":"12588","%standard-featured-credit%":"","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%post_via%":[{"title":"Area 15 - Laurent Velasquez","post_source_url":""},{"title":"Area 15 - Peter Ruprecht","post_source_url":""}],"%_yoast_indexnow_last_ping%":"1677015010","taxonomy=category":"Bezienswaardigheden Las Vegas","taxonomy=post_tag":"Nevada","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":12584,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Pinnacles National Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pinnacles National Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/08/pinnacles-np-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Pinnacles National Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Californi\u00eb 95043, Verenigde Staten","location":{"lat":"36.4905655","state":"Californi\u00eb","country":"Verenigde Staten","lng":"-121.1824925","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/pinnacles-national-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Pinnacles National Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een van de minder bekende nationale parken in Californi\u00eb is het Pinnacles National Park. Het park dat ten zuiden van San Francisco ligt, wordt een stuk minder bezocht dan het naastgelegen Yosemite National Park. Dit komt deels doordat het gebied minder toegankelijk is, maar eigenlijk de voornaamste reden omdat het minder bekend is dan zijn naastgelegen broer. Het gebied is ruig en vooral bedekt met rotsen. Toch kun je er prachtige dieren zien, mooie wandelingen maken en vooral de klimliefhebbers komen hier aan hun trekken. Ben je in Californi\u00eb? Reis dan eens via Pinnacles National Park.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]200 kilometer vanaf San Francisco[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">107 km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-paw\"]48 verschillende soorten dieren[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"De grotten van Pinnacles National Park\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Door de vulkaanuitbarsting miljoenen jaren geleden bestaat Pinnacles National Park grotendeels uit rotsen. Deze rotsen bevatten vele grotten waar Pinnacles om bekend staat. En het zijn niet alleen indrukwekkende grotten, er leven 13 verschillende soorten vleermuizen. Een aantal van deze grotten zijn toegankelijk voor publiek (broedseizoen eventueel uitgesloten). Aan de oostkant van het park kun je de Bear Gulch Cave bezoeken en aan de westkant Balconies Cave. Beiden liggen op 1,5 uur lopen van de bezoekerscentra in beide delen. Naast vleermuizen kun je ook geluk hebben om de prairievalk te spotten of de Californische Condor.</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Bear Gulch Cave\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Hoeveel vleermuizen kun jij ontdekken?\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"12520\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Facts Pinnacles National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Door een vulkaanuitbarsting miljoenen jaren geleden ziet het landschap van Pinnacles National Park er onherbergzaam uit. Je kunt het park opdelen in een oost- en westkant. De oostkant is een lager gedeelte waar je ook water vindt, de westkant bestaat uit steile rotsformaties. Er zijn geen doorgaande wegen in het park, je kunt het alleen te voet doorkruizen. In het oosten kun je met alle voertuigen komen, het westen is niet toegankelijk voor grote campers. Pinnacles is sinds 2013 een National Park.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Wat te doen in Pinnacles National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Pinnacles National Park biedt voldoende mogelijkheden om te wandelen en te klimmen. Vooral voor de laatste groep is het park een walhalla met meer dan 300 verschillende klim spots. Gedurende het seizoen worden er diverse activiteiten georganiseerd in het park. Hierbij wordt verteld over het ontstaan van het park en de flora en fauna die je tegen kunt komen. Naast wandelen in het park, kun je ook de vele grotten bezoeken.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten in Pinnacles National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In het park zijn geen mogelijkheden om in hotels of appartementen te overnachten. Je vindt het hele jaar door de mogelijkheid om te kamperen op een campground waar je kunt kamperen met eigen tent of gebruik kun maken van een tent cabin die hier staan. Hier kunnen 4 personen in slapen.\u00a0 Check nog wel even van te voren of er <a href=\"https://www.recreation.gov/camping/pinnacles-campground/r/campgroundDetails.do?contractCode=NRSO&amp;parkId=73984\">plek</a> is.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reisperiode Pinnacles National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Je kunt Pinnacles National Park in principe het hele jaar door bezoeken. Wij raden toch aan om de zomermaanden over te slaan. In juli en augustus\u00a0 liggen de gemiddelde temperaturen rond de 35 graden. Je kunt Pinnacles NP beter in het voor- en najaar bezoeken. In de winter is het qua temperatuur goed te doen, zo'n 15-20 graden, maar valt er meer neerslag.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Trails in Pinnacles National Park\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"Ontdek het park op een van de wandelpaden\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"12521\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelen in Pinnacles National Park\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]Pinnacles National Park kun je het beste te voet verkennen. Er zijn ongeveer 50 kilometer aan trails te vinden in het park. De twee grotten waar je naar toe kunt wandelen zijn aanraders (Bear Gulch en Balconies Cave). Andere aanraders voor <a href=\"https://www.nps.gov/pinn/planyourvisit/trails.htm\" target=\"_blank\" rel=\"noopener\">wandelroutes</a> zijn Condor Gulch Overlook (ongeveer 4 kilometer), High Peaks Loop (ongeveer 9 kilometer) en de wandeling door Bear Gulch (ongeveer 4 kilometer). De wandeling hebben verschillende zwaartes en zijn vaak in een loop.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]Oostkant: 24/7 en 365 dagen geopend\r\nWestkant: 7.30 -20.00 uur, alleen daggebruik[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: voor- en najaar[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]7 daagse pas voor auto's: $30\r\n7 daagse pas voor voetgangers: $15[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Bear Gulch Area\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"Een van de meest bezochte delen van het park\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"12519\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Meer nationale parken\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:4738,4714,4689,4792\"][/vc_column][/vc_row]","post_title":"Pinnacles National Park","post_link":"https://www.heyusa.com/nl/pinnacles-national-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pinnacles National Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/08/pinnacles-np-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Pinnacles National Park","post_tags":"Californi\u00eb","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%inline_featured_image%":"0","%_edit_lock%":"1703756592:2","%_edit_last%":"1","%_thumbnail_id%":"12522","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Pinnacles National Park","%_yoast_wpseo_metadesc%":"In Californi\u00eb ligt het Pinnacles National Park. Tips voor een bezoek aan het Pinnacles National Park.","%_yoast_wpseo_linkdex%":"69","%_wpgmp_location_address%":"Californi\u00eb 95043, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Californi\u00eb","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"36.4905655","%_wpgmp_metabox_longitude%":"-121.1824925","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_primary_category%":"177","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015011","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Pinnacles National Park","taxonomy=post_tag":"Californi\u00eb","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png"},"id":12504,"infowindow_disable":false},{"source":"post","title":"Zwemmen in New York City","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Zwemmen in New York\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/07/Astoria-zwembad-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Zwemmen in New York City</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1071 5th Ave, New York, NY 10128, Verenigde Staten","location":{"lat":"40.7829796","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.9589706","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/zwemmen-new-york-city/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"25px\"][ultimate_heading main_heading=\"Zwemmen in New York\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]<strong>De zomers in New York zijn warm, temperaturen boven de 35 graden zijn geen uitzondering. De meeste locals vluchten de stad uit voor de hitte, voor de achterblijvers zijn er genoeg middelen om af te koelen. Zo kun je gebruik maken van de gratis openbare zwembaden die je inmiddels door heel New York vindt. Dit zijn een aantal openbare zwembaden waar je op een hete zomerdag gebruik van kunt maken en tips om een middagje zwembad te overleven ;)\r\n</strong>[/vc_column_text][vc_empty_space height=\"25px\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Openbare zwembaden in New York\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Iedere zomer maken duizenden inwoners van New York gebruik van de <a href=\"https://www.nycgovparks.org/facilities/outdoor-pools\" target=\"_blank\" rel=\"noopener\">gratis openbare zwembaden</a> die je door de stad vindt. De meeste outdoor zwembaden zijn geopend van 11.00 uur - 19.00 uur met een pauze tussen 15.00-16.00 uur. Je vindt de zwembaden verspreid over New York in The Bronx, <a href=\"https://www.heyusa.com/nl/newyork/brooklyn/\">Brooklyn</a>, Manhattan, Queens en <a href=\"https://www.heyusa.com/nl/wat-te-doen-in-staten-island-new-york/\">Staten Island</a>.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Astoria Pool in Queens\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Perfecte escape op een warme dag in NYC\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"12450\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Openbare zwembaden in New York\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"De plek om even af te koelen in de zomer\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"McCarren Park Pool\" heading_tag=\"h3\" main_heading_color=\"#223656\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"Brooklyn\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:21px;\"][/ultimate_heading][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>Williamsburg / Greenpoint | McCarren Park</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-subway\"]<strong>Bedford Avenue | L</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-sun-o\"]<strong>1x zwembad (olympische afmeting)</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Astoria Pool\" heading_tag=\"h3\" main_heading_color=\"#223656\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"Queens\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:21px;\"][/ultimate_heading][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>Astoria | 19th Street and 23rd Drive</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-subway\"]<strong>Astoria Boulevard | N | W</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-sun-o\"]<strong>1x zwembad (olympische afmeting)</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Hamilton Fish Pool\" heading_tag=\"h3\" main_heading_color=\"#223656\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"Manhattan\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:21px;\"][/ultimate_heading][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>Lower East Side | Pitt Street &amp; Houston Street</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-subway\"]<strong>Delancy Street - Essex Street | F | M | J | Z</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-sun-o\"]<strong>2 zwembaden (olympisch + kinderbad)</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Asser Levy Pool\" heading_tag=\"h3\" main_heading_color=\"#223656\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"Manhattan\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:21px;\"][/ultimate_heading][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>Midtown Manhattan | 390 Asser Levy Pl</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-subway\"]<strong>23 St | 6</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-sun-o\"]<strong>2 zwembaden (groot + kinderbad)</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Dry Dock Pool\" heading_tag=\"h3\" main_heading_color=\"#223656\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"Manhattan\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:21px;\"][/ultimate_heading][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>Lower East Side | 149 E 10th Street</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-subway\"]<strong>Delancy Street - Essex Street | F | M | J | Z</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-sun-o\"]<strong>2 zwembaden (groot + kinderbad)</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Commodore Barry Pool\" heading_tag=\"h3\" main_heading_color=\"#223656\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"Brooklyn\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:21px;\"][/ultimate_heading][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>Downtown Brooklyn | Flushing Avenue</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-subway\"]<strong>York Street | F</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-sun-o\"]<strong>2 zwembaden (groot + kinderbad)</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"John Jay Pool\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"Manhattan\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:21px;\"][/ultimate_heading][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>Upper East Side | 77 Cherokee Pl</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-subway\"]<strong>72 St | Q</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-sun-o\"]<strong>2 zwembaden (groot + kinderbad)</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Douglas and DeGraw Pool\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"Brooklyn\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:21px;\"][/ultimate_heading][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>Cobble Hill | Third Avenue &amp; Nevins Street</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-subway\"]<strong>Union Station | R</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-sun-o\"]<strong>2 zwembaden (olympisch + kinderbad)</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Sunset Pool\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"Brooklyn\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:21px;\"][/ultimate_heading][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>Sunset Park | 7th Avenue</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-subway\"]<strong>45 St | R</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-sun-o\"]<strong>1x zwembad (olympische afmeting)</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1619098125380{padding-top: 75px !important;padding-bottom: 75px !important;background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2021/02/background-dc-light.gif?id=4055) !important;}\"][vc_column][fullwidth_row content_width=\"75%\"][ultimate_heading main_heading=\"Do's &amp; Don'ts bij openbare zwembaden in New York\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Voordat je gaat zwemmen in een van de openbare zwembaden in New York, een paar handige tips:</p>\r\n[/vc_column_text][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Do's bij openbare zwembaden in New York\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_column_text]\r\n<ul>\r\n \t<li>Draag fatsoenlijke zwemkledij</li>\r\n \t<li>Om niet te verbranden wordt een wit shirt aangeraden (geen gekleurde shirts)</li>\r\n \t<li>Draag zonnebrand</li>\r\n \t<li>Neem een slot mee op je waardevolle spullen in een kluisje op te bergen</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Don'ts bij openbare zwembaden in New York\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_column_text]\r\n<ul>\r\n \t<li>Neem geen eten en drinken (in glas mee)</li>\r\n \t<li>Ook elektronische apparaten en kranten kun je beter niet meenemen</li>\r\n \t<li>Laat voor de zekerheid waardevolle spullen in je hotel of appartement</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ook leuk in New York City:\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][fullwidth_row][thb_postgrid columns=\"4\" source=\"post_type:post|by_id:1594,1312,408,1559\"][/vc_column][/vc_row]","post_title":"Zwemmen in New York City","post_link":"https://www.heyusa.com/nl/zwemmen-new-york-city/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Zwemmen in New York\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/07/Astoria-zwembad-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Stedentrips","post_tags":"New York","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1619098125380{padding-top: 75px !important;padding-bottom: 75px !important;background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2021/02/background-dc-light.gif?id=4055) !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1669214184:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Zwemmen in New York","%_yoast_wpseo_title%":"Zwemmen in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Ben je in de zomer in New York en wil je ergens zwemmen? Check dan dit lijstje met openbare zwembaden in New York","%_yoast_wpseo_linkdex%":"72","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"1071 5th Ave, New York, NY 10128, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7829796","%_wpgmp_metabox_longitude%":"-73.9589706","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"12452","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_primary_category%":"62","%post_via%":[{"title":"Foto credits: Joe Buglewicz/NYC & Company","post_source_url":"nycgo.com"},{"title":"","post_source_url":""}],"%_yoast_indexnow_last_ping%":"1677015022","taxonomy=category":"Stedentrips","taxonomy=post_tag":"New York","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":12448,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Dry Tortugas National Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Dry Tortugas National Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/07/dry-tortugas-np-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Dry Tortugas National Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Dry Tortugas, Florida, Verenigde Staten","location":{"lat":"24.6651511","state":"Florida","country":"Verenigde Staten","lng":"-82.8553984","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/dry-tortugas-national-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Dry Tortugas National Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Dry Tortugas National Park ligt op de open zee op 109 kilometer vanaf Key West. De zeven losse eilanden zijn alleen per boot of vliegtuig bereikbaar. Ze staan bekend om de mooie koraalriffen, vissen en vogels. Dat daarnaast vele legendes over piraten en geschonken schatten de ronde gaan bij de eilanden, trekt alleen maar meer mensen aan. Het 19e eeuws fort Fort Jefferson is een van de redenen om die boottocht naar Dry Tortugas National Park te boeken.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]109 kilometer vanaf Key West[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">262 km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-paw\"]300 verschillende soorten dieren[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"De droge eilanden\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">In 1513 werden de kleine eilanden voor de kust van Florida ontdekt door de Spanjaarden. Droge eilanden zonder water en veel zeeschildpadden en voila, daar was de naam Dry Tortugas. De eilanden werden een belangrijke strategische plek voor Noord Amerika. Met de bouw van Fort Jefferson werden de eilanden beschermd tegen vijandige boten. Daarnaast konden schepen schuilen voor stormen of hun voorraden aanvullen. Op de hoogtijdagen woonden er 2000 mensen in het fort.</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Fort Jefferson\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Publiekstrekker van Dry Tortugas\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"12407\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Facts Dry Tortugas National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De eilanden werden nog tot 1874 gebruikt door het leger. In de twee wereldoorlogen werd het fort nogmaals gebruikt. Daarna diende het vooral voor koolstation van oorlogsschepen. Nadat het eerst tot National Wildlife Refuge werd uitgeroepen in 1908, het Jefferson Fort tot National Monument in 1935, werd het in 1992 een National Park. Met 262 km2 aan redelijk ongerepte koraalriffen is het gebied een van de mooiste natuurgebieden van Amerika. Tegenwoordig bezoeken zo'n 60.000 mensen jaarlijks Dry Tortugas National Park[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Wat te doen in Dry Tortugas National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een van de publiekstrekkers van de eilanden is Fort Jefferson. Het ligt op het een na grootste eiland van de Dry Tortugas, Garden Key. Het grootste eiland van Dry Tortugas is Loggerhead Key en is 365 dagen per jaar te bezoeken, maar is wat lastig te bereiken. Je hebt een eigen boot of kajak nodig om het eiland te bereiken. Op Loggerhead Key vind je vele scheepswrakken en vele zeeschildpadden. Van februari tot september is het eiland Bush Key gesloten voor publiek, tientallen vogels nemen dan het eiland over. De Dry Tortugas zijn perfect om te snorkelen, te duiken, kajakken, suppen en om de vele dieren te bekijken.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten op Dry Tortugas National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Er zijn weinig mogelijkheden om te overnachten op de Dry Tortugas eilanden. Op Garden Key is een kleine camping. Plekken gaan op basis van beschikbaarheid. Bezoekers met een boot, mogen op hun boot overnachten maar moeten eigen eten en drinken meenemen. Dit geldt ook voor de kampeerders. Er zijn geen faciliteiten om vers water, eten of gas te verkrijgen.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reisperiode Dry Tortugas National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Dry Tortugas National Park is 365 dagen per jaar geopend. Florida staat bekend om de goede temperaturen het hele jaar door. Toch is het goed om van te voren het weer te checken. Tussen december en maart is het het winter storm seizoen en tussen juni en november het zomer storm seizoen. Tijdens de zomer is het er warm, in de winter zijn de temperaturen zachter.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Garden Key\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"De enige plek om te kamperen op de eilanden\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"12406\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Snorkelen op de Dry Tortugas\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]De beste manier om Dry Tortugas te verkennen is onder water, het grootste deel van het nationale park bevindt zich namelijk hier. Het ligt in de zuidwestelijke hoek van het Florida Keys rif, het op 2 na grootste rif ter wereld. Door de afgelegen ligging en de oostelijke stroming, heb je grote kans om prachtige vissen te zien onder water.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]24/7 en 365 dagen geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: april en mei[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]7 daagse pas: $15 - vaak zit de prijs al bij de ferry inbegrepen[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Dry Tortugas National Park\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"Plek om wildlife te zien\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"12408\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Meer nationale parken\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:4738,4714,4689,4792\"][/vc_column][/vc_row]","post_title":"Dry Tortugas National Park","post_link":"https://www.heyusa.com/nl/dry-tortugas-national-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Dry Tortugas National Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/07/dry-tortugas-np-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Dry Tortugas National Park","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%inline_featured_image%":"0","%_edit_lock%":"1658382586:2","%_edit_last%":"1","%_thumbnail_id%":"12405","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Lassen Volcanic National Park","%_yoast_wpseo_metadesc%":"In Californi\u00eb ligt een van de minst bezochte parken van Amerika: Lassen Volcanic National Park. Tips voor een bezoek aan het park vol vulkanen.","%_yoast_wpseo_linkdex%":"57","%_wpgmp_location_address%":"Dry Tortugas, Florida, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"24.6651511","%_wpgmp_metabox_longitude%":"-82.8553984","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_primary_category%":"176","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015029","taxonomy=category":"Dry Tortugas National Park","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png"},"id":12401,"infowindow_disable":false},{"source":"post","title":"Duval Street Key West","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Overseas Highway roadtrip\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/07/key-west-duval-street-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Duval Street Key West</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Staten Island Ferry, Staten Island, NY, Verenigde Staten","location":{"lat":"40.6468667","state":"New York","country":"Verenigde Staten","lng":"-74.0683612","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/duval-street-key-west/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"25px\"][vc_custom_heading text=\"Duval Street Key West\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Duval Street is de hoofdstraat van Key West en de plek waar het allemaal gebeurt. Hoewel de straat maar 2 kilometer is, heeft het de bijnaam 'de langste straat ter wereld'.\u00a0 Duval Street loopt van de Golf van Mexico naar de Atlantische Oceaan. Het is het kloppende hart van de Conch Republic en zit boordevol winkels, restaurants, galerijen en attracties.\u00a0</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Gratis[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612950540814{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Conch Republic\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Duval Street is de plek waar de Conch Republiek is ontstaan. Het is een micronatie die op 23 april 1982 is uitgeroepen tot een afscheiding van de stad Key West als reactie op de wegblokkades van de Amerikaanse grenspolitie. Sindsdien verwijst de term naar alle Florida Keys. Je kunt de beroemde Conch Republic vlag met een schelp spotten op het eiland. Ben je in Key West geboren? Dan word je een Conchs genoemd. Ben je ergens anders geboren, maar woon je wel in <a href=\"https://www.heyusa.com/nl/key-west/\">Key West</a>? Dan heet je een 'fresh water conchs'.</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Duval Street\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"De plek om te shoppen in Key West\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"12354\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Wat te doen in Duval Street?\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/4\"][vc_custom_heading text=\"Shop 'Til you Drop\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Wil je shoppen in Key West? Dan is Duval Street de aangewezen plek. Een breed assortiment aan galerie\u00ebn, winkels en unieke boetieks zorgen ervoor dat je niet met lege handen Key West verlaat. Ook voor typische Cubaanse souvenirs is Duval Street de plek om te shoppen.\r\n</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][vc_custom_heading text=\"De leukste restaurants op Duval Street\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Voor een authentieke Key West ervaring qua eten en drinken kun je plaatsnemen bij een van de vele restaurants in Duval Street. Vaak onder het genot van live muziek kun je hier heerlijk eten. Leuke restaurants zijn: Jimmy Buffet, Nine One Five Bistro, Hot Tin Roof en Fogarty's. Je vindt er tal van legendarische bars (zoals Sloppy Joe's Bar en Green Parrot Bar) en uitgaansgelegenheden (Rick's Bar / Duty Harry). Voor live muziek kun je het beste naar Honky Tonk Saloon van de La Te Da en Cowboy Bill.</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][vc_custom_heading text=\"Vele festivals\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Duval Street staat bekend om de vele festivals die er jaarlijks plaatsvinden. Zo wordt het beroemde Key West Food &amp; Wine Festival ieder jaar gehouden in Duval Street. Ook het Conch Republic Independence Festival is een van de populairste festivals waarbij de straat een week lang eten, muziek en verschillende activiteiten staat. En natuurlijk mag Halloween niet ontbreken op de festival kalender, een 10 daags event alleen voor volwassenen.\r\n</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][vc_custom_heading text=\"Oldest House Museum and Garden\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Een oud schelphuisje uit 1829 is het oudste gebouw van de straat. Tegenwoordig de plek voor The <a href=\"https://oirf.org/\" target=\"_blank\" rel=\"noopener\">Oldest House Museum and Garden</a> waarin je antiek meubilair, maritieme artefacten en familiestukken kunt bewonderen.\u00a0</span>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Sloppy Joe's Bar Duval Street\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Een van de plekken om een drankje te doen\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"12355\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Key West\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:12341,12289,12282,9784\"][/vc_column][/vc_row]","post_title":"Duval Street Key West","post_link":"https://www.heyusa.com/nl/duval-street-key-west/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Overseas Highway roadtrip\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/07/key-west-duval-street-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Florida Keys","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1612950540814{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"2","%_edit_lock%":"1685517931:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"14","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":[{"title":"Foto credit Staten Island Ferry: Julienne Schaer/NYC & Company","post_source_url":"http://www.nycgo.com"},{"title":"Foto credit Staten Island Ferry: Matthew Penrod/NYC & Company","post_source_url":"nycgo.com"},{"title":"Foto credit Staten Island Ferry: Jen Davis/NYC & Company","post_source_url":"nycgo.com"}],"%_thumbnail_id%":"12310","%_yoast_wpseo_focuskw%":"Duval Street","%_yoast_wpseo_title%":"%%title%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"De beroemdste straat van Key West is Duval Street. De plek om te shoppen of uit eten te gaan. Tips voor Duval Street","%_yoast_wpseo_linkdex%":"82","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Duval Street Key West\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"Staten Island Ferry, Staten Island, NY, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.6468667","%_wpgmp_metabox_longitude%":"-74.0683612","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"175","%_yoast_indexnow_last_ping%":"1685518064","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Florida Keys","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":12348,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Key West zeiltocht bij zonsondergang","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"zeiltocht key west\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/07/zeiltocht-key-west-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Key West zeiltocht bij zonsondergang</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"201 William St, Key West, FL 33040, Verenigde Staten","location":{"lat":"24.5611876","city":"Key West","state":"Florida","country":"Verenigde Staten","lng":"-81.8012985","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/zonsondergang-zeiltocht-key-west/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Key West zeiltocht bij zonsondergang\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"20px\"][vc_column_text]Een unieke ervaring om de zonsondergang van de Keys te zien is met een <a href=\"https://www.getyourguide.nl/key-west-l552/key-west-zeiltocht-bij-zonsondergang-met-open-bar-eten-en-muziek-t390631/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=keywestzeilenzonsondergangintekst\" target=\"_blank\" rel=\"noopener\">zeilboot</a> vanaf het water rondom <a href=\"https://www.heyusa.com/nl/key-west/\">Key West</a>. Geniet tijdens de cruise van een onbeperkte bar met een breed scala aan drankjes. Natuurlijk kunnen hapjes niet ontbreken bij deze ervaring. Een grote variatie aan hapjes is aanwezig, ook voor vegetari\u00ebrs zijn er genoeg mogelijkheden. Op een van de nieuwste catamarans vaar je naar het beste plek voor de zonsondergang. In combinatie met een drankje en live muziek is dit een unieke ervaring. En mocht je zelf kunnen zeilen, je mag altijd helpen met het hijsen van de zeilen of het besturen van de boot. Deze Key West zeiltocht bij zonsondergang is een van de aanraders om te boeken wanneer je op de Keys bent.[/vc_column_text][vc_custom_heading text=\"Handige informatie voor Key West zeiltocht bij zonsondergang\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<b>Prijs</b><span style=\"font-weight: 400;\">: Vanaf 68 euro\r\n</span><span style=\"font-weight: 400;\"><strong>Duur</strong>: 2 uur\r\n</span><b>Locatie</b><span style=\"font-weight: 400;\">: 201 William St, Key West</span><span style=\"font-weight: 400;\">\r\n</span><b>Openingstijden:</b> Van maandag tot en met zondag om 18.30 uur[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fkey-west-l552%2Fkey-west-zeiltocht-bij-zonsondergang-met-open-bar-eten-en-muziek-t390631%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26cmp%3Dkeywestzeilenzonsondergang|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"20px\"][/vc_column][vc_column width=\"1/3\"][thb_image retina=\"retina_size\" box_shadow=\"medium-shadow\" thb_border_radius=\"10px\" image=\"12345\"][/thb_image][vc_empty_space height=\"20px\"][vc_column_text][/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Key West &amp; Miami\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:12262,12074,12063,9784\"][/vc_column][/vc_row]","post_title":"Key West zeiltocht bij zonsondergang","post_link":"https://www.heyusa.com/nl/zonsondergang-zeiltocht-key-west/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"zeiltocht key west\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/07/zeiltocht-key-west-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Florida Keys","post_tags":"Florida","%_edit_last%":"2","%_edit_lock%":"1685517161:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"168","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style3","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":{"2":{"title":"","post_source_url":""}},"%_yoast_wpseo_focuskw%":"Key West zeiltocht bij zonsondergang","%_yoast_wpseo_metadesc%":"Een toffe activiteit is de Key West zeiltocht bij zonsondergang. Bekijk de zonsondergang op een zeilboot onder het genot van een drankje.","%_yoast_wpseo_linkdex%":"69","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Key West zonsondergang\"]","%_wpgmp_location_address%":"201 William St, Key West, FL 33040, Verenigde Staten","%_wpgmp_location_city%":"Key West","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"24.5611876","%_wpgmp_metabox_longitude%":"-81.8012985","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"12342","%inline_featured_image%":"0","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"","%_yoast_indexnow_last_ping%":"1685517116","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Florida Keys","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":12341,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Hemingway House and Museum","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hemingway House and Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/07/ernest-hemingway-house-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Hemingway House and Museum</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"907 Whitehead St, Key West, FL 33040, Verenigde Staten","location":{"lat":"24.5512115","city":"Key West","state":"Florida","country":"Verenigde Staten","lng":"-81.8006044","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/hemingway-house-museum/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"25px\"][ultimate_heading main_heading=\"Hemingway House and Museum in Key West\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]<strong>Het voormalig huis van literair icoon Ernest Hemingway vind je op Key West. Hij is een van de meest geliefde 'freshwater Conchs' zoals ze dat noemen op de Keys, een inwoner die niet op het eiland geboren is. Het huis was tot zijn dood in zijn bezit en is tegenwoordig een nationaal historisch monument van de VS. Benieuwd wat je kunt doen bij het Hemingway House en Museum?\r\n</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Key West | 907 Whitehead St.\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek je tickets\" btn_link=\"url:https%3A%2F%2Fwww.hemingwayhome.com%2F|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"De plek waar Hemingway enkele beroemde stukken schreef\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Het optrekje van Hemingway waar hij ongeveer 10 jaar doorbracht, is de plek waar hij enkele beroemde werken schreef. Delen van 'A Farewell to Arms' en 'For Whom the Bell Toll's werden geschreven in zijn huis op <a href=\"https://www.heyusa.com/nl/key-west/\">Key West</a>. Zijn huis was in die tijd nogal vooruitstrevend omdat het een van de eerste huizen in Key West was met overdekt sanitair en een zwembad.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Hemingway House and Museum\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Bekijk het huis van de legendarische schrijver Hemingway\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"12326\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen in het Hemingway House\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Rondleiding\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Onder leiding van een deskundige gids krijg je meer te horen over het leven van schrijver Ernest Hemingway. Het is de beste manier om meer te weten te komen over zijn leven, zijn boeken en het huis. De rondleiding duurt ongeveer 20 tot 30 minuten.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"De tuinen van het Hemingway huis\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In de tuinen van het Hemingway Huis vind je prachtige designaccenten die de vrouw van Hemingway heeft aangebracht. Ook hier zie je het zwembad dat voor de periode dat hij gebouwd werd een architectonisch hoogtestandje was. De bouw zorgde destijds voor nogal wat ophef. Het zwembad wordt omringd door prachtige fauna.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"De katten van Hemingway\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Een museum en ongeveer 60 levende katten? Het Hemingway Home and Museum is de thuisbasis voor ongeveer 60 zestenige katten. Normaal hebben katten 5 aan de voorkant en 4 achter, deze katten hebben allemaal een polydactyl eigenschap. Hemingway kreeg ooit een kat met 6 tenen en sommige katten die er nog rondlopen, stammen af van deze kat.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"De tuinen van het Hemingway House and Museum\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Spot een van de katten met 6 tenen\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"12325\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ook leuk in Key West\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][fullwidth_row][thb_postgrid style=\"style4\" columns=\"4\" source=\"post_type:post|by_id:12289,12282,12262,9784\"][/vc_column][/vc_row]","post_title":"Hemingway House and Museum","post_link":"https://www.heyusa.com/nl/hemingway-house-museum/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hemingway House and Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/07/ernest-hemingway-house-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Florida Keys","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1685514067:2","%_edit_last%":"2","%_wpb_vc_js_status%":"true","%post-primary-category%":"16","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Hemingway House and Museum","%_yoast_wpseo_title%":"Hemingway House and Museum Key West %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Op zoek naar een tof museum over de schrijver Hemingway? Dan moet je zijn bij het Hemingway House and Museum in Key West.","%_yoast_wpseo_linkdex%":"67","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"907 Whitehead St, Key West, FL 33040, Verenigde Staten","%_wpgmp_location_city%":"Key West","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"24.5512115","%_wpgmp_metabox_longitude%":"-81.8006044","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"12324","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"175","%_yoast_indexnow_last_ping%":"1685514151","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Florida Keys","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":12322,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Key West","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Overseas Highway roadtrip\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/07/key-west-duval-street-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Key West</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"South Beach, Miami Beach, Florida 33139, Verenigde Staten","location":{"lat":"25.7826123","city":"Miami Beach","state":"Florida","country":"Verenigde Staten","lng":"-80.1340772","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/key-west/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"25px\"][heyusa_heading tag=\"div\" heading=\"De Florida Keys\" font_size=\"45\" line_height=\"50\" font_color=\"#b34a4c\"][ultimate_heading main_heading=\"Key West\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\" margin_design_tab_text=\"\"][/ultimate_heading][ultimate_heading main_heading=\"Wat te doen in Key West\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:35px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_column_text]<strong>Key West op de Florida Keys wordt gezien als het meest zuidelijke punt van Amerika. Het is de plek voor watersport, uitgaan, de mooiste stranden, historische plekken en de onderwaterwereld. Het eiland is zo'n 6,6 kilometer lang en maar 2 kilometer breed, toch heeft het veel te bieden qua vermaak en bezienswaardigheden. Rijdt de Overseas Highway op en ontdek wat je allemaal kunt doen op Key West.</strong>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1640066907439{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"300px\"][vc_custom_heading text=\"Key West\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Bekend van de prachtige stranden\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"300px\"][parallax_row opacity=\"90\" enable_mobile=\"parallax-enable-mobile\" image=\"12311\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Key West - het zuidelijkste deel van Amerika\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Dichter bij Cuba dan Miami. En die sfeer proef je op Key West, het meest zuidelijke deel van Amerika en de Florida Keys. Key West biedt verschillende mogelijkheden om de oceaan op te gaan en de onderwaterwereld te ontdekken. Maar ook Key West zelf kun je op verschillende manieren ontdekken, denk aan een Hop on Hop off die je direct mogelijkheden biedt om verschillende (historische) bezienswaardigheden te bezoeken. Verschillende musea vertellen over historische schatten op het eiland. Daarnaast zijn er tal van restaurants en bars waar je terecht kunt voor een diner of borrel.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][vc_custom_heading text=\"WAT TE DOEN IN KEY WEST\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_row_inner css=\".vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"12302\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Truman White House\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het kleine witte huis in Key West werd oorspronkelijk gebouwd in 1890 als het hoofdkwartier van de marine tijdens verschillende oorlogen. Vanaf 1946 ging Harry Truman het huis gebruiken tijdens zijn wintervakanties en werd het huis omgedoopt tot het Kleine Witte Huis. Na het aftreden van Truman gingen ook latere presidenten zoals Carter en Clinton op vakantie naar het Little White House. Tegenwoordig is het een museum waar je van alles kunt vinden over de geschiedenis van Key West en de gebeurtenissen tijdens het presidentschap van Truman.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Key West | 8311, 111 Front St.\"][ult_buttons btn_title=\"Boek je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fkey-west-l552%2Ftruman-little-white-house-key-west-t18344%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dkeywesttrumanlittlehouse|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"12303\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Southernmost Point\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een foto bij het meest zuidelijke punt van de Verenigde Staten kan natuurlijk niet ontbreken wanneer je in Key West bent! De gestreepte en opvallende boei ligt op slechts 144 kilometer van Cuba. Daarnaast vind je er ook een plaquette met een herdenking aan de vele Cubanen die de overtocht naar Amerika niet overleefden en een plaquette met details over de zwarte gemeenschap in dit gebied. Officieel is het trouwens niet helemaal het meest zuidelijke punt van Amerika, dat ligt net een stuk ten westen, maar dat gebied is eigendom van de Marine.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Key West | Corner of Whitehead Street and South Street\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"12304\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Shipwreck Museum\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In de wateren van de Florida Keys blijken een heleboel schepen verloren te zijn gegaan. In het Shipwreck Museum in Key West wordt het verhaal vertelt over meer dan 400 jaar scheepswrakken uit deze regio. Aan de hand van acteurs, films en artefacten worden verschillende verhalen verteld. Het museum zelf is een reconstructie van een oud 19e eeuws pakhuis van Asa Tift. Veel artefacten zijn afkomstig uit de herontdekking in 1985 van het vernielde schip Isaac Allerton dat in 1856 zonk op een rif voor de kust, het bleek een van de rijkste scheepswrakken uit de geschiedenis van Key West te zijn.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Key West | 1 Whitehead St\"][ult_buttons btn_title=\"Boek je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fkey-west-l552%2Fkey-west-shipwreck-historeum-t18304%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dkeywestshipwreckmuseum|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][/vc_row_inner][vc_row_inner css=\".vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"12305\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Key West Lighthouse\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De huidige vuurtoren van Key West werd in 1848 in gebruik genomen met een vrouw als vuurtorenwachter, destijds een uniek gegeven. In de jaren erna onderging de vuurtoren diverse keren een upgrade, maar zoals zovele vuurtorens werd ook deze niet meer nodig. In 1969 was het niet meer nodig om de vuurtoren op Key West te gebruiken. Je kunt de vuurtoren van Key West bezoeken en de 88 treden beklimmen en zien hoe de families van vuurtorenwachters leefden.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Key West | 938 Whitehead Street\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"12306\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Mallory Square\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Op het meest noordwestelijke deel van Key West vind je Mallory Square. Het is de plek om de zon in de zee te zien zakken. Ongeveer 2 uur voor zonsondergang vindt er Celebration Sunset plaats, een nachtelijk kunstfestival. Hoewel dit de beste plek is voor zonsondergang, is het direct ook de drukste plek om te zijn tijdens zonsondergang.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Key West | 400 Wall St.\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"12331\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Fort Zachary Taylor Historic State Park\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Fort Zachary Taylor Historic State Park is een plek die je om verschillende redenen kunt bezoeken. Je kunt ervoor kiezen om het fort te bezoeken en een rondleiding te volgen om zo meer te weten te komen over de Spaans-Amerikaanse oorlog. Een andere reden om het Fort Zachary Taylor Historic State Park te bezoeken zijn de fantastische snorkel mogelijkheden. Het water is helder waardoor het de perfecte plek is om te snorkelen.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Key West | 01 Howard England Way\"][/vc_column_inner][/vc_row_inner][vc_row_inner css=\".vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"12337\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Key West Museum of Art and History\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Key West Museum of Art en History is een plek geworden waar je veel verschillende objecten vindt die de geschiedenis representeren van de Keys. In het oude Custom House dat ooit dienst deed als douanegebouw, postkantoor, rechtbank en later als als gebouw van de Amerikaanse marine, vind je tegenwoordig de Key West Art &amp; Historical Society. Het doel is om de cultuur van de Florida Keys te behouden. Je kunt tentoonstellingen bezoeken die te maken hebben met kunst, architectuur en geschiedenis van de Keys.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Key West | 281 Front Street\"][/vc_column_inner][vc_column_inner width=\"1/3\"][/vc_column_inner][vc_column_inner width=\"1/3\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Activiteiten op Key West\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_blockgrid source=\"size:10|post_type:post|by_id:-12322,12294,12289,12282,12272,12262,12341\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" thb_row_padding=\"true\" thb_column_padding=\"true\" content_placement=\"middle\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][thb_image retina=\"retina_size\" full_width=\"true\" image=\"12354\"][/thb_image][/vc_column][vc_column width=\"1/2\"][vc_row_inner][vc_column_inner width=\"5/6\"][heyusa_heading tag=\"div\" heading=\"Shop til you drop\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][vc_custom_heading text=\"Duval Street\" font_container=\"tag:h3|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Duval Street loopt van de Golf van Mexico naar de Atlantische Oceaan en is de hoofdstraat van Key West. Het is de plek waar het allemaal gebeurt in Key West. Hoewel <a href=\"https://www.heyusa.com/nl/duval-street-key-west/\">Duval Street</a> maar 2 kilometer is, heeft het de bijnaam \u2018de langste straat ter wereld\u2019.\u00a0 Het kloppende hart van de Conch Republic en zit boordevol winkels, restaurants, galerijen en attracties.[/vc_column_text][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fduval-street-key-west%2F|title:Duval%20Street\" btn_size=\"ubtn-small\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:25px;\" btn_line_height=\"desktop:30px;\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" thb_row_padding=\"true\" thb_column_padding=\"true\" content_placement=\"middle\"][vc_column width=\"1/2\"][vc_row_inner][vc_column_inner width=\"5/6\"][heyusa_heading tag=\"div\" heading=\"Literair Icoon\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][vc_custom_heading text=\"Hemingway House and Museum\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het voormalig huis van literair icoon Ernest Hemingway is tegenwoordig een museum en nationaal historisch monument. Hij is een van de meest geliefde \u2018freshwater Conchs\u2019 zoals ze dat noemen op de Keys, een inwoner die niet op het eiland geboren is. Het huis in Key West was tot zijn dood in zijn bezit. Ontdek het <a href=\"https://www.heyusa.com/nl/hemingway-house-museum/\">Hemingway House en Museum</a> tijdens je bezoek aan Key West.[/vc_column_text][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fhemingway-house-museum%2F|title:Hemingway%20House%20and%20Museum\" btn_size=\"ubtn-small\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:25px;\" btn_line_height=\"desktop:30px;\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][thb_image retina=\"retina_size\" full_width=\"true\" image=\"12324\"][/thb_image][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][thb_postbackground source=\"post_type:post|by_id:9784\"][fullwidth_row content_width=\"100%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1606171128628{padding-top: 75px !important;padding-bottom: 75px !important;}\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"25px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][vc_custom_heading text=\"Meer inspiratie:\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][thb_postgrid style=\"style4\" columns=\"4\" source=\"post_type:post|by_id:12074,12063,9784,8724\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row]","post_title":"Key West","post_link":"https://www.heyusa.com/nl/key-west/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Overseas Highway roadtrip\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/07/key-west-duval-street-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Florida Keys","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1640066907439{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1606171128628{padding-top: 75px !important;padding-bottom: 75px !important;}.vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}.vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}.vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1689232524:1","%_edit_last%":"1","%_hide_featured%":null,"%_wpgmp_location_address%":"South Beach, Miami Beach, Florida 33139, Verenigde Staten","%_wpgmp_location_city%":"Miami Beach","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.7826123","%_wpgmp_metabox_longitude%":"-80.1340772","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Key West\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"7","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%inline_featured_image%":"0","%_yoast_wpseo_primary_category%":"175","%_thumbnail_id%":"12310","%standard-featured-credit%":"","%_yoast_wpseo_focuskw%":"Wat te doen in Key West","%_yoast_wpseo_metadesc%":"Wat te doen in Key West? Tips voor bezienswaardigheden in Key West om niet te missen tijdens je bezoek!","%_yoast_wpseo_linkdex%":"77","%thb-reactions-votes%":"1","%_yoast_wpseo_title%":"Wat te doen in %%title%% %%page%% %%sep%% %%sitename%%","%_yoast_indexnow_last_ping%":"1689083347","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Florida Keys","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png"},"id":12301,"infowindow_disable":false},{"source":"post","title":"Key West Conch Train","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Key West Conch Train rondrit\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/07/Conch-Train-rondrit-key-west-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Key West Conch Train</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"501 Front St, Key West, FL 33040, Verenigde Staten","location":{"lat":"24.5605222","city":"Key West","state":"Florida","country":"Verenigde Staten","lng":"-81.80599629999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/key-west-conch-train-rondrit/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Key West Conch Train\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_column_text]Meer zien van Key West? Stap dan in de Key West Conch <a href=\"https://www.getyourguide.com/key-west-l552/conch-train-tour-in-key-west-t15343/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=conchtrainkeywestintekst\" target=\"_blank\" rel=\"noopener\">Train-rondrit</a>. In 90 minuten maak je kennis met verschillende bezienswaardigheden van Key West terwijl je rustig wordt rondgereden. Je kunt onderweg uitstappen bij Truval Village voor een bezoek aan onder andere het Ernest Hemmingway House, Key West Lighthouse, het meest zuidelijke puntje van de US en het Key West Butterfly en Nature Conservatory. Onderweg kom je meer te weten over allerlei gebeurtenissen in de omgeving en de geschiedenis van <a href=\"https://www.heyusa.com/nl/key-west/\">Key West</a>.[/vc_column_text][vc_custom_heading text=\"Handige informatie voor de Key West Conch Train rondrit\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<b>Duur:</b> 90 minuten<b>\r\nPrijs</b><span style=\"font-weight: 400;\">: Vanaf 38 euro</span><span style=\"font-weight: 400;\">\r\n</span><b>Locatie</b><span style=\"font-weight: 400;\">: 501 Front St, Key West</span><span style=\"font-weight: 400;\">\r\n</span><b>Openingstijden:</b> Van maandag tot en met zondag tussen 10.15 en 16.15 uur[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fkey-west-l552%2Fconch-train-tour-in-key-west-t15343%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dconchtrainkeywest|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"20px\"][/vc_column][vc_column width=\"1/3\"][thb_image retina=\"retina_size\" box_shadow=\"medium-shadow\" thb_border_radius=\"10px\" image=\"12297\"][/thb_image][vc_empty_space height=\"20px\"][vc_column_text][/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Key West &amp; Miami\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:12262,12074,12063,9784\"][/vc_column][/vc_row]","post_title":"Key West Conch Train","post_link":"https://www.heyusa.com/nl/key-west-conch-train-rondrit/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Key West Conch Train rondrit\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/07/Conch-Train-rondrit-key-west-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Florida Keys","post_tags":"Florida","%_edit_last%":"2","%_edit_lock%":"1685448320:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"168","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style3","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":{"2":{"title":"","post_source_url":""}},"%_yoast_wpseo_focuskw%":"Key West Conch Train","%_yoast_wpseo_metadesc%":"Met de Key West Conch Train zie je in 90 minuten vele bezienswaardigheden van Key West. Boek deze rondrit om meer te zien van Key West.","%_yoast_wpseo_linkdex%":"69","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Conch Train\"]","%_wpgmp_location_address%":"501 Front St, Key West, FL 33040, Verenigde Staten","%_wpgmp_location_city%":"Key West","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"24.5605222","%_wpgmp_metabox_longitude%":"-81.80599629999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"12296","%inline_featured_image%":"0","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"","%_yoast_indexnow_last_ping%":"1685448249","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Florida Keys","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":12294,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Dolfijnen spotten in Key West","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Dolfijnen spotten\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/07/dolfijn-key-west-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Dolfijnen spotten in Key West</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"201 William St, Key West, FL 33040, Verenigde Staten","location":{"lat":"24.5611876","city":"Key West","state":"Florida","country":"Verenigde Staten","lng":"-81.8012985","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/dolfijnen-spotten-key-west/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Dolfijnen spotten in Key West\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_column_text]Met de Sunset One ga je een poging wagen om <a href=\"https://www.getyourguide.com/key-west-l552/key-west-dolphin-combo-boat-tour-t282687/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=dolfijnenkeywestintekst\" target=\"_blank\" rel=\"noopener\">dolfijnen te spotten</a> in Key West. Met een gids ga je de wateren rondom <a href=\"https://www.heyusa.com/nl/key-west/\">Key West</a> verkennen en hopelijk komen er dolfijnen voorbij zwemmen. Je vaart richting het Key West National Wildlife Refugee waar zich een aantal kleine eilanden bevinden, de kans is groot dat hier dolfijnen zwemmen. Maar je hebt ook kans om kleurrijke vissen, schildpadden en haaien te zien. In dit gebied mag je snorkelen om al deze dieren van dicht bij te zien.[/vc_column_text][vc_custom_heading text=\"Handige informatie voor het spotten van dolfijnen in Key West\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<b>Duur:</b> 3 uur<b>\r\nPrijs</b><span style=\"font-weight: 400;\">: Vanaf 72 euro</span><span style=\"font-weight: 400;\">\r\n</span><b>Locatie</b><span style=\"font-weight: 400;\">: 6201 William St, Key West, FL</span><span style=\"font-weight: 400;\">\r\n</span><b>Openingstijden:</b> Excursies starten om 11.00 uur\r\n<strong>Belangrijk:\u00a0</strong>Paspoort meenemen, zwemkleding, zonnebrand. Snorkelset krijg je daar[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fkey-west-l552%2Fkey-west-dolphin-combo-boat-tour-t282687%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Ddolfijnenkeywest|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"20px\"][/vc_column][vc_column width=\"1/3\"][vc_empty_space height=\"20px\"][vc_column_text][/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Key West &amp; Miami\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:12262,12074,12063,9784\"][/vc_column][/vc_row]","post_title":"Dolfijnen spotten in Key West","post_link":"https://www.heyusa.com/nl/dolfijnen-spotten-key-west/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Dolfijnen spotten\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/07/dolfijn-key-west-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Florida Keys","post_tags":"Florida","%_edit_last%":"2","%_edit_lock%":"1685448323:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"168","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style3","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":{"2":{"title":"","post_source_url":""}},"%_yoast_wpseo_focuskw%":"Dolfijnen spotten in Key West","%_yoast_wpseo_metadesc%":"Bekijk het enige levende rif van Noord Amerika vanuit Key West. Met deze excursie ga je dolfijnen spotten in Key West.","%_yoast_wpseo_linkdex%":"69","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Dolfijnen Key West\"]","%_wpgmp_location_address%":"201 William St, Key West, FL 33040, Verenigde Staten","%_wpgmp_location_city%":"Key West","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"24.5611876","%_wpgmp_metabox_longitude%":"-81.8012985","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"12290","%inline_featured_image%":"0","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"","%_yoast_indexnow_last_ping%":"1685448363","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Florida Keys","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":12289,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Snorkelen Key West","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Snorkelen Key West\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/07/key-west-snorkel-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Snorkelen Key West</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"631 Greene St, Key West, FL 33040, Verenigde Staten","location":{"lat":"24.5609308","city":"Key West","state":"Florida","country":"Verenigde Staten","lng":"-81.80334839999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/key-west-snorkelen/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Snorkelen Key West\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_column_text]Om het enige levende koraalrif van Noord Amerika te zien, moet je een duik maken bij Key West. Tijdens een trip van 3 uur kun je genieten van de onderwaterwereld rondom Key West. Met een catamaran word je naar de mooiste plekken gebracht om te <a href=\"https://www.getyourguide.com/key-west-l552/double-dip-2-stop-key-west-reef-snorkel-t74246/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=snorkelenkeywestintekst\" target=\"_blank\" rel=\"noopener\">snorkelen</a> in <a href=\"https://www.heyusa.com/nl/key-west/\">Key West</a>. Deze tocht is inclusief drankjes en mimosa's na het snorkelen. Dus na actief te hebben gesnorkeld kun je genieten van de zon onder het genot van een biertje en wat lekkers. Ben je ooit eerder mee geweest? Dan kun je natuurlijk nog een keer mee, de onderwaterwereld verveeld nooit![/vc_column_text][vc_custom_heading text=\"Handige informatie om te snorkelen Key West\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<b>Duur:</b> 3 uur<b>\r\nPrijs</b><span style=\"font-weight: 400;\">: Vanaf 58 euro</span><span style=\"font-weight: 400;\">\r\n</span><b>Locatie</b><span style=\"font-weight: 400;\">: 241 Front Street, Opal Key Marina</span><span style=\"font-weight: 400;\">\r\n</span><b>Openingstijden:</b> De ochtend snorkelexcursie begint om 9.30 uur en de middag om 13.00 uur\r\n<strong>Belangrijk:\u00a0</strong>Paspoort meenemen, zwemkleding, zonnebrand. Snorkelset krijg je daar[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fkey-west-l552%2Fdouble-dip-2-stop-key-west-reef-snorkel-t74246%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dsnorkelenkeywest|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"20px\"][/vc_column][vc_column width=\"1/3\"][thb_image retina=\"retina_size\" box_shadow=\"medium-shadow\" thb_border_radius=\"10px\" image=\"12284\"][/thb_image][vc_empty_space height=\"20px\"][vc_column_text][/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Key West &amp; Miami\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:12262,12074,12063,9784\"][/vc_column][/vc_row]","post_title":"Snorkelen Key West","post_link":"https://www.heyusa.com/nl/key-west-snorkelen/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Snorkelen Key West\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/07/key-west-snorkel-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Florida Keys","post_tags":"Florida","%_edit_last%":"2","%_edit_lock%":"1685448324:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"168","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style3","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":{"2":{"title":"","post_source_url":""}},"%_yoast_wpseo_focuskw%":"Snorkelen Key West","%_yoast_wpseo_metadesc%":"Bekijk het enige levende rif van Noord Amerika vanuit Key West. Met deze excursie ga je snorkelen bij het rif in Key West.","%_yoast_wpseo_linkdex%":"69","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Snorkelen Keys\"]","%_wpgmp_location_address%":"631 Greene St, Key West, FL 33040, Verenigde Staten","%_wpgmp_location_city%":"Key West","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"24.5609308","%_wpgmp_metabox_longitude%":"-81.80334839999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"12283","%inline_featured_image%":"0","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"","%_yoast_indexnow_last_ping%":"1685448383","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Florida Keys","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":12282,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Key West Aquarium","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Key west Aquarium\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/07/key-west-aquarium-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Key West Aquarium</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1 Whitehead St, Key West, FL 33040, Verenigde Staten","location":{"lat":"24.55907","city":"Key West","state":"Florida","country":"Verenigde Staten","lng":"-81.807332","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/key-west-aquarium/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Key West Aquarium\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"20px\"][vc_column_text]Hoe het is om een haai te aaien of een zeester vast te houden? Je weet het wanneer je het Key West <a href=\"https://www.getyourguide.nl/key-west-aquarium-l110267/toegangsticket-key-west-aquarium-t18302/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=keywestaquariumintekst\" target=\"_blank\" rel=\"noopener\">Aquarium</a> hebt bezocht. Je vindt er tal van indrukkende zeedieren als pijlstaartroggen, barracuda's, haaien en zeeschildpadden. Niet alleen heb je de kans om deze dieren van dicht bij te bekijken zonder nat te worden, je krijgt ook allerlei informatie over hun leefgebieden en gewoontes. Natuurlijk kun je er bij zijn wanneer de haaien gevoed worden, op drie verschillende momenten gedurende de dag worden ze gevoed. En het leuke is dat het Key West Aquarium ook nog eens een historische plek inneemt in de geschiedenis van de stad; het was in 1934 de allereerste attractie van <a href=\"https://www.heyusa.com/nl/key-west/\">Key West</a>.[/vc_column_text][vc_custom_heading text=\"Handige informatie voor het Key West Aquarium\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<b>Prijs</b><span style=\"font-weight: 400;\">: Vanaf 19 euro</span><span style=\"font-weight: 400;\">\r\n</span><b>Locatie</b><span style=\"font-weight: 400;\">: Whitehead St. Mallory Square 1 Key West</span><span style=\"font-weight: 400;\">\r\n</span><b>Openingstijden:</b> Van maandag tot en met zondag van 10.00 - 18.00 uur[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fkey-west-aquarium-l110267%2Ftoegangsticket-key-west-aquarium-t18302%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26cmp%3Dkeywestaquarium|title:Bestel%20je%20tickets\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"20px\"][/vc_column][vc_column width=\"1/3\"][thb_image retina=\"retina_size\" box_shadow=\"medium-shadow\" thb_border_radius=\"10px\" image=\"12274\"][/thb_image][vc_empty_space height=\"20px\"][vc_column_text][/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Key West &amp; Miami\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:12262,12074,12063,9784\"][/vc_column][/vc_row]","post_title":"Key West Aquarium","post_link":"https://www.heyusa.com/nl/key-west-aquarium/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Key west Aquarium\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/07/key-west-aquarium-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Florida Keys","post_tags":"Florida","%_edit_last%":"2","%_edit_lock%":"1685448242:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"168","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style3","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":{"2":{"title":"","post_source_url":""}},"%_yoast_wpseo_focuskw%":"Key West Aquarium","%_yoast_wpseo_metadesc%":"Bezoek het Key West Aquarium om kennis te maken met diverse zeedieren. Tips voor je bezoek aan het Kew West Aquarium","%_yoast_wpseo_linkdex%":"72","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Aquarium Keys\"]","%_wpgmp_location_address%":"1 Whitehead St, Key West, FL 33040, Verenigde Staten","%_wpgmp_location_city%":"Key West","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"24.55907","%_wpgmp_metabox_longitude%":"-81.807332","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"12275","%inline_featured_image%":"0","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"","%_yoast_indexnow_last_ping%":"1685446689","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Florida Keys","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":12272,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Hop on Hop off in Key West","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hop on Hop off Miami\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/07/hop-on-hop-off-key-west-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Hop on Hop off in Key West</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"501 Front St, Key West, FL 33040, Verenigde Staten","location":{"lat":"24.5605222","city":"Key West","state":"Florida","country":"Verenigde Staten","lng":"-81.80599629999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/hop-on-hop-off-key-west/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Hop on Hop off in Key West\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een leuke en relaxte manier om bepaalde plekken in een stad of gebied te ontdekken is per Hop on Hop off. Ook in Key West kun je het eiland en de stad ontdekken met de Old Town Trolley. Genieten van de zon en ondertussen de mooiste plekken zien van Key West, een ultieme combinatie. Met deze Old Town Trolley kun je heel Key West ontdekken en heb je geen problemen met het zoeken van parkeerplekken. Kortom de <a href=\"https://www.getyourguide.com/key-west-l552/from-key-west-old-town-trolley-12-stop-hop-on-hop-off-tour-t15340/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=oldtowntrolleykeywestintekst\" target=\"_blank\" rel=\"noopener\">Hop on Hop off</a> in Key West is een leuke manier om bezienswaardigheden te ontdekken en ook nog wat van het eiland te zien.[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]Hele jaar door[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf \u20ac48[/ultimate_icon_list_item][/ultimate_icon_list][ult_buttons btn_title=\"Boek je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fkey-west-l552%2Ffrom-key-west-old-town-trolley-12-stop-hop-on-hop-off-tour-t15340%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Doldtowntrolleykeywestbovenin|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Stap in de Hop on Hop off in Key West\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Op 12 verschillende plekken kun je uitstappen bij de Old Town Trolley om verschillende bezienswaardigheden te bezoeken in <a href=\"https://www.heyusa.com/nl/key-west/\">Key West</a>. Denk aan bezienswaardigheden als Mallory Square, Historic Waterfront of Truman's Little White House. Natuurlijk kan een stop bij de Southernmost Point, de meest zuidelijke plek van Amerika, ook niet ontbreken. Combineer het bezoeken van bezienswaardigheden op Key West met een ontspannen ritje in de Hop on Hop off en stap af en toe uit om de leukste bars en restaurants te bezoeken.</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Hop on Hop off in Key West\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Al tourend Key West ontdekken\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"12267\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tickets voor de Hop on Hop off in Key West\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Tickets voor de Hop on Hop off kun je het beste van te voren online kopen.\r\n<ul>\r\n \t<li>Voor volwassenen een ticket vanaf 48 euro</li>\r\n \t<li>Voor kinderen een ticket vanaf 17 euro</li>\r\n</ul>\r\n[/vc_column_text][ult_buttons btn_title=\"Boek je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fkey-west-l552%2Ffrom-key-west-old-town-trolley-12-stop-hop-on-hop-off-tour-t15340%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Doldtowntrolleykeywestonderin|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie Hop on Hop off in Key West\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>12 stops, meer dan 100 bezienswaardigheden onderweg</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Tussen 10.00 uur en 15.30 uur</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-automobile car\"]<strong>Parkeren kan bij Mallory Square; de parkeergarage van The Westin of in het welkomstcentrum van Key West</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space][fullwidth_row][vc_custom_heading text=\"Andere interessante artikelen\" font_container=\"tag:div|font_size:65|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"size:4|order_by:date|order:DESC|post_type:post|by_id:9784,4725,3764,12074,11682\"][/vc_column][/vc_row]","post_title":"Hop on Hop off in Key West","post_link":"https://www.heyusa.com/nl/hop-on-hop-off-key-west/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hop on Hop off Miami\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/07/hop-on-hop-off-key-west-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Florida Keys","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}","%_edit_last%":"2","%_edit_lock%":"1685448325:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Hop on Hop off in Key West","%_yoast_wpseo_metadesc%":"De Hop on Hop off Key West is een leuke manier om de stad te verkennen. Tips voor het nemen van de Hop on Hop off Key West.","%_yoast_wpseo_linkdex%":"79","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Hop on Hop off\"]","%_wpgmp_location_address%":"501 Front St, Key West, FL 33040, Verenigde Staten","%_wpgmp_location_city%":"Key West","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"24.5605222","%_wpgmp_metabox_longitude%":"-81.80599629999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_thumbnail_id%":"12266","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"","%_yoast_indexnow_last_ping%":"1685448459","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Florida Keys","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":12262,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Vizcaya Museum and Garden Miami","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"wat te doen miami\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/09/vizcaya-museum-en-gardens-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Vizcaya Museum and Garden Miami</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Vizcaya Museum and Gardens Main House, 3251 S Miami Ave, Miami, FL 33129, Verenigde Staten","location":{"lat":"25.7443866","city":"Miami","state":"Florida","country":"Verenigde Staten","lng":"-80.21047469999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/vizcaya-museum-garden-miami/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Vizcaya Museum en Garden\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:35px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:40px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]<strong>Vizcaya Museum and Gardens in Miami, beter bekend als Villa Vizcaya, is de voormalige woning van zakenman James Deering. Het prachtige landgoed van de Villa Vizcaya omvat Italiaanse renaissancetuinen, een inheems boslandschap en historische gebouwen. De 34 kamers van het huis zijn ingericht in Italiaanse renaissancestijl. Een waar pareltje om te ontdekken. Tips voor een bezoek aan het Vizcaya Museum and Gardens.</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"1001 Ocean Drive Miami Beach\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fvizcaya.org%2F|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ontstaan van Villa Vizcaya\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Begin 20e eeuw was James Deering een schatrijke industrieel. Hij miste helaas een rijke familiegeschiedenis met bijbehorende oude huizen. En wat doe je dan? Dan bouw je zelf een landhuis in oude Italiaanse renaissance stijl. Rond 1916 was het huis met 34 kamers klaar. Deering struinde heel Europa af voor meubilair en kunst. Het huis is bezocht door niemand minder dan paus Johannes Paulus II, Queen Elizabeth en verschillende presidenten. Geen verkeerde plek om doorheen te wandelen.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Vizcaya Gardens\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ontdek de weelderige tuin in Italiaanse stijl\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"10147\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat te doen in het Vizcaya Museum en Garden\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Vizcaya Museum\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Meer dan 1000 arbeiders waren er nodig om het huis van zijn dromen te realiseren; Villa <a href=\"https://vizcaya.org/\" target=\"_blank\" rel=\"noopener\">Vizcaya</a>. Ondertussen speurde Deering zelf Europa af op zoek naar passen meubilair, kunst en beelden. De collectie komt grotendeels uit Itali\u00eb met af en toe items uit Frankrijk. In 34 kamers vind je schatten die zelfs uit de 15e eeuw kunnen dateren. Bezoek de verschillende kamers waar diverse beroemdheden genoten tijdens hun verblijf aan de vila.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Vizcaya Gardens\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Het landgoed waar Villa Vizcaya op staat is ingericht in Italiaanse stijl. Overal vind je doorkijkjes, verborgen hoeken, veel beelden en fonteinen. Toch vind je ook een vleugje van de tropische omgeving waarin de tuin zich bevindt terug. Palmbomen, zeldzame orchidee\u00ebn en Cubaanse kalksteen ontbreken niet in de tuin. Neem naast het museum ook de tijd om de Vizcaya Gardens te ontdekken.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ook leuk in Miami\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][fullwidth_row][thb_postgrid columns=\"4\" source=\"size:4|post_type:post|by_id:15153,14375,12090,13984\"][/vc_column][/vc_row]","post_title":"Vizcaya Museum and Garden Miami","post_link":"https://www.heyusa.com/nl/vizcaya-museum-garden-miami/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"wat te doen miami\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/09/vizcaya-museum-en-gardens-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Miami","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1685433675:2","%_edit_last%":"2","%_wpb_vc_js_status%":"true","%post-primary-category%":"168","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Vizcaya Museum and Gardens Miami\"]","%_yoast_wpseo_focuskw%":"Vizcaya Museum and Gardens","%_yoast_wpseo_metadesc%":"Ontdek het prachtige huis en de tuin van de Vizcaya Museum and Gardens Miami. Tips voor het Vizcaya Museum and Gardens in Miami.","%_yoast_wpseo_linkdex%":"74","%_wpgmp_location_address%":"Vizcaya Museum and Gardens Main House, 3251 S Miami Ave, Miami, FL 33129, Verenigde Staten","%_wpgmp_location_city%":"Miami","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.7443866","%_wpgmp_metabox_longitude%":"-80.21047469999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_thumbnail_id%":"8882","%post_via%":"","%_yoast_wpseo_primary_category%":"168","%_yoast_indexnow_last_ping%":"1685433740","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Bezienswaardigheden Miami","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":12112,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Coconut Grove Miami","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coconut Grove\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/05/coconut-grove-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Coconut Grove Miami</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"South Beach, Miami Beach, Florida 33139, Verenigde Staten","location":{"lat":"25.7826123","city":"Miami Beach","state":"Florida","country":"Verenigde Staten","lng":"-80.1340772","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/miami/coconut-grove-miami/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"25px\"][ultimate_heading main_heading=\"Coconut Grove Miami\" heading_tag=\"span\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][ultimate_heading main_heading=\"Wat te doen in Coconut Grove Miami\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:35px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_column_text]<strong>Coconut Grove in Miami is een van de meest historische wijken van de stad en misschien ook wel de mooiste. Aan de baai van Coconut Grove hangt een tropische sfeer, palmbomen en banyan bomen ontbreken niet in dit plaatje. Boerenmarkten, kunstgalerijen, historische zwarte kerken, zeilclubs, winkels en vele eetgelegenheden zijn de reden om richting Coconut Grove te trekken. Benieuwd wat je er precies kunt doen? Tips voor Coconut Grove in Miami.\u00a0</strong>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1640066907439{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"300px\"][vc_custom_heading text=\"Coconut Grove\" font_container=\"tag:div|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Biscayne Bay area\" font_container=\"tag:div|font_size:35|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"300px\"][parallax_row opacity=\"90\" enable_mobile=\"parallax-enable-mobile\" image=\"12102\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Coconut Grove - de mooiste wijk van Miami\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Hoewel je het misschien niet verwacht is Coconut Grove is een bestemming voor natuurliefhebbers. Een tweetal historische landgoederen draagt daaraan bij. The Vizcaya Museum and Gardens en The Barnacle Historic State Park bieden mogelijkheden om uit de drukte van de stad te ontsnappen.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][vc_custom_heading text=\"WAT TE DOEN IN COCONUT GROVE MIAMI\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_row_inner css=\".vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"12104\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"CocoWalk Mall\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]CocoWalk voelt een beetje als een dorp in de wijk Coconut Grove. Het is de plek om te winkelen en andere locals te ontmoeten. Binnenin het winkelcentrum, dat een oppervlakte heeft van 100.00 vierkante meter, vind je onafhankelijke boetieks, de bekende merken en een tropische tuin.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Coconut Grove | 3015 Grand Avenue\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"12105\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Peacock Park\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Peacock Park is een heerlijke plek om even te relaxen in Miami. Met uitzicht op Biscayne Bay hoef je je niet te vervelen. Er zijn tal van recreatiemogelijkheden in het park, zowel indoor als outdoor. Het Peacock Park is een eerbetoon aan het echtpaar Peacock die hier ooit een hotel hadden, een van de eerste hotels in dit gebied. Zij hebben veel bijgedragen met het hotel aan de ontwikkeling van het gebied.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Coconut Grove | 2820 McFarlane Road\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"12107\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"The Barnacle Historic State Park\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In het Barnacle Historic State Park worden bezoekers meegenomen naar het einde van de 19e eeuw. Het huis dat in het state park staat, The Barnacle, is het oudste huis in Miami Dade County dat nog op zijn oorspronkelijke locatie staat. The Barnacle was van zakenman Ralph Middleton Munroe die gezien werd als een pionier in Coconut Grove. Aan het park is al die jaren weinig veranderd. Voor vogelliefhebbers is de plek een walhalla met spechten, ijsvogels, pelikanen een aalscholvers.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Coconut Grove | 485 Main Hwy\"][/vc_column_inner][/vc_row_inner][vc_row_inner css=\".vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" thb_row_padding=\"true\" thb_column_padding=\"true\" content_placement=\"middle\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][thb_image retina=\"retina_size\" full_width=\"true\" image=\"10147\"][/thb_image][/vc_column][vc_column width=\"1/2\"][vc_row_inner][vc_column_inner width=\"5/6\"][heyusa_heading tag=\"div\" heading=\"Landgoed Vila Vizcaya\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][vc_custom_heading text=\"Vizcaya Museum and Gardens\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<a href=\"https://www.heyusa.com/nl/vizcaya-museum-garden-miami/\">Vizcaya Museum and Gardens</a> in Miami, beter bekend als Villa Vizcaya, is de voormalige woning van zakenman James Deering. Een prachtige landgoed met Italiaanse renaissancetuinen, een inheems boslandschap, een museum en historische gebouwen. Het enorme huis met meer dan 34 kamers, is ingericht in Italiaanse renaissancestijl. In combinatie met de prachtige tuinen een aanrader om te bezoeken in Miami.[/vc_column_text][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fvizcaya-museum-garden-miami%2F|title:Vizcaya%20Museum%20en%20Garden\" btn_size=\"ubtn-small\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:25px;\" btn_line_height=\"desktop:30px;\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][thb_postbackground source=\"post_type:post|by_id:9817\"][fullwidth_row content_width=\"100%\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"75px\"][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ontdek andere leuke wijken in Miami!\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][ultimate_heading main_heading=\"Bezoek andere wijken naast Coconut Grove\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:40px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:45px;\"][/ultimate_heading][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"25px\"][thb_postbackground style=\"style2\" source=\"by_id:-12101,12074,12063,11669,-1262,-2267,-883,-850,-572,-557,-545,-456,11771\"][/vc_column][/vc_row]","post_title":"Coconut Grove Miami","post_link":"https://www.heyusa.com/nl/miami/coconut-grove-miami/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coconut Grove\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/05/coconut-grove-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Miami","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1640066907439{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}.vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1685432826:2","%_edit_last%":"2","%_hide_featured%":null,"%_wpgmp_location_address%":"South Beach, Miami Beach, Florida 33139, Verenigde Staten","%_wpgmp_location_city%":"Miami Beach","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.7826123","%_wpgmp_metabox_longitude%":"-80.1340772","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Coconut Grove\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%inline_featured_image%":"0","%_yoast_wpseo_primary_category%":"167","%_thumbnail_id%":"12103","%standard-featured-credit%":"","%_yoast_wpseo_focuskw%":"Coconut Grove Miami","%_yoast_wpseo_metadesc%":"Wat te doen in Coconut Grove? Tips voor bezienswaardigheden in Coconut Grove om niet te missen tijdens je bezoek!","%_yoast_wpseo_linkdex%":"81","%thb-reactions-votes%":"1","%_yoast_wpseo_title%":"Wat te doen in %%title%% %%page%% %%sep%% %%sitename%%","%_yoast_indexnow_last_ping%":"1685432473","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Miami","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png"},"id":12101,"infowindow_disable":false},{"source":"post","title":"Cruise Downtown Miami naar miljonairshuizen op Venetiaanse eilanden","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"cruise miljonairshuizen\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/05/cruise-miljonairshuizen-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Cruise Downtown Miami naar miljonairshuizen op Venetiaanse eilanden</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"325 S Biscayne Blvd, Miami, FL 33131, Verenigde Staten","location":{"lat":"25.7717055","city":"Miami","state":"Florida","country":"Verenigde Staten","lng":"-80.18637319999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/cruise-downtown-miami/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Cruise Downtown Miami langs miljonairshuizen en eilanden\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_column_text]Stap in Downtown Miami aan boord van deze cruise die je langs prachtige huizen brengt. Op een luxe boot vaar je richting Star Island met prachtige herenhuizen, daarna wordt Biscayne Bay aangedaan. Hier kun je nog een glimp opvangen van het huis van Al Capone. Andere beroemde Venetiaanse eilanden die bezocht worden zijn Hibiscus Island, Palm Island, Sunset Island en Fischer Island.\r\n\r\nJe kunt de huizen van vele beroemdheden zien vanaf de luxe boot. Zo zie je huizen van P. Diddy, Enrique Iglesias, Phil Colins en Jennifer Lopez.[/vc_column_text][vc_custom_heading text=\"Handige informatie voor cruise langs miljonairshuizen\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<b>Duur:</b><span style=\"font-weight: 400;\"> vanaf 1,5 uur</span><span style=\"font-weight: 400;\">\r\n</span><b>Prijs</b><span style=\"font-weight: 400;\">: Vanaf 30 euro</span><span style=\"font-weight: 400;\">\r\n</span><b>Vertreklocatie</b><span style=\"font-weight: 400;\">: 325 S Biscayne Boulevard, parkeren in de omgeving is betaald</span><span style=\"font-weight: 400;\">\r\n</span><b>Tijden: </b>Tussen 10.00 uur en 18.30 uur; vertrek ieder half uur[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fdowntown-miami-l5963%2Fmiami-boat-cruise-to-millionaires-row-and-venetian-islands-t395313%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dcruisemiljonairshuizen|title:Bestel%20je%20tickets\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"20px\"][/vc_column][vc_column width=\"1/3\"][thb_image retina=\"retina_size\" box_shadow=\"medium-shadow\" thb_border_radius=\"10px\" image=\"12093\"][/thb_image][vc_empty_space height=\"20px\"][vc_column_text][/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Miami\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:12074,11682,11610,10769\"][/vc_column][/vc_row]","post_title":"Cruise Downtown Miami naar miljonairshuizen op Venetiaanse eilanden","post_link":"https://www.heyusa.com/nl/cruise-downtown-miami/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"cruise miljonairshuizen\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/05/cruise-miljonairshuizen-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Miami","post_tags":"","%_edit_last%":"1","%_edit_lock%":"1685432918:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"168","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style3","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":{"2":{"title":"","post_source_url":""}},"%_yoast_wpseo_focuskw%":"Cruise Downtown Miami","%_yoast_wpseo_metadesc%":"Een cruise in Downtown Miami naar miljonairshuizen op de Venetiaanse eilanden rondom Biscayne Bay.","%_yoast_wpseo_linkdex%":"56","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Cruise miljonairshuizen Miami\"]","%_wpgmp_location_address%":"325 S Biscayne Blvd, Miami, FL 33131, Verenigde Staten","%_wpgmp_location_city%":"Miami","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.7717055","%_wpgmp_metabox_longitude%":"-80.18637319999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"12091","%inline_featured_image%":"0","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"168","%_yoast_indexnow_last_ping%":"1677015039","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Bezienswaardigheden Miami","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":12090,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Lassen Volcanic National Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lassen Volcanic National Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/05/lassen-peak-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Lassen Volcanic National Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Californi\u00eb, Verenigde Staten","location":{"lat":"40.49766","state":"Californi\u00eb","country":"Verenigde Staten","lng":"-121.4206552","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/lassen-volcanic-national-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Lassen Volcanic National Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een van de minst bezochte nationale parken in Amerika is Lassen Volcanic National Park. Hier kun je nog echt de wildernis ervaren in het 43.000 hectare grote park. Door de verschillen in hoogte, van ongeveer 1500 meter tot 3000 meter, is er een enorme diversiteit aan natuur en aan dieren. Het gebied is geothermisch actief met borrelende modderpoelen en warmwaterbronnen. De Lassen Peak is de hoogste berg van het park met 3187 meter en een slapende vulkaan. Meer informatie en tips voor Lassen Volcanic National Park.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]250 kilometer vanaf Sacramento[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">429 km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-paw\"]300 verschillende soorten dieren[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Lassen Peak\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">De Lassen Peak is met zijn 3187 meter de opvallendste plek in het Lassen Volcanic National Park. De berg is door de instorting van Mount Tehama zo'n 350.000 jaar geleden, de meest zuidelijke actieve vulkaan in het Cascadegebergte. Na deze instorting was er van Mount Tehama weinig meer over, de vulkanische activiteit bleef in het gebied en in het noorden van het park ontstonden nieuwe kraters. De hoogste daarvan is Lassen Peak. Deze vulkaan kwam in 1915 nog tot uitbarsting, sinds 1921 slaapt Lassen Peak. Het gebied rondom is nog steeds geothermisch zeer actief.</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Cinder Cone vulkaan\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Een van de vier soorten vulkanen in het park\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"12001\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Facts Lassen Volcanic National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Lassen Peak en Cinder Cone werden in 1917 aangeduid als kleine nationale monumenten door president Theodore Roosevelt. Door de uitbarstingen in het vulkanisch gebied veranderde het landschap enorm. Een reden om in 1916 het gebied te kenmerken als Nationaal Park. In het Lassen Volcanic National Park kun je vier verschillende types vulkanen vinden: lavakoepel, schildvulkaan, slakkenkegel en stratovulkaan. Het is een van de weinige plekken op aarde waar al deze vier soorten voorkomen.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Hoogtepunten in Lassen Volcanic National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Je rijdt het nationale park vanuit het westen binnen via de Lassen Volcanic Park Highway, de enige verharde weg door het park. Vanaf hier kun je de Lassen Peak vanuit verschillende hoeken zien, stoppen bij verschillende plekken waar wandelroutes beginnen en stoppen bij highlights in het park. Hoogtepunten in het park zijn onder andere Sulphur Works, Ridge Lakes, Lake Helen, Summit Lake, Hot Rock en onder andere de pieken van Lassen Peak en Mount Shasta.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten in het Lassen Volcanic National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Er zijn niet veel mogelijkheden om te overnachten in Lassen Volcanic National Park. De <a href=\"https://lassenlodging.com/drakesbad/\" target=\"_blank\" rel=\"noopener\">Drakesbad Guest Ranch</a> biedt mogelijkheden om te overnachten in lodges, hutten en bungalows. In Werner Valley vind je een kampeerterrein.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reisperiode Lassen Volcanic National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Van november tot en met mei is de highway door Lassen Volcanic NP gesloten vanwege de sneeuwval. Je kunt dan alleen voor wintersporten terecht in het park. Alleen tochten op sneeuwschoenen en langlaufen zijn mogelijk. De beste maanden om te wandelen in het park zijn augustus en september.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Bumpass Hell\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"Gebied vol geothermische activiteiten\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"12000\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelingen &amp; trails\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]In Lassen Volcanic National Park zijn diverse wandelingen waarbij je het gevoel hebt in de wildernis te zijn. Daarnaast zijn er een aantal wandelingen langs geothermische gebieden van het park. Zo kun je met de Bumpass Hell Trail (5 kilometer) een wandeling maken langs allemaal warmwaterbronnen. Een andere mooie wandeling in het park is de Lassen Peak Trail (ongeveer 8 kilometer). Hierbij beklim je de top de van de Lassen Peak en maak je een stijging van 2576 meter naar 3187 meter. Bij helder weer heb je vanaf hier een prachtig uitzicht![/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]24/7 en 365 dagen geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: augustus en september[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]7 daagse pas met auto of camper: $30[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-ticket\" content_font_size=\"desktop:16px;\"]$15 per persoon voor 7 dagen[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-location-arrow\" content_font_size=\"desktop:16px;\"]Meer dan 240 kilometer aan wandelpaden[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Lassen Volcanic National Park\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"E\u00e9n van de minst bezochte parken in Amerika\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"12002\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Meer nationale parken\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:4738,4714,4689,4792\"][/vc_column][/vc_row]","post_title":"Lassen Volcanic National Park","post_link":"https://www.heyusa.com/nl/lassen-volcanic-national-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lassen Volcanic National Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/05/lassen-peak-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Lassen Volcanic National Park","post_tags":"Californi\u00eb","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%inline_featured_image%":"0","%_edit_lock%":"1703755644:2","%_edit_last%":"1","%_thumbnail_id%":"12003","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Lassen Volcanic National Park","%_yoast_wpseo_metadesc%":"In Californi\u00eb ligt een van de minst bezochte parken van Amerika: Lassen Volcanic National Park. Tips voor een bezoek aan het park vol vulkanen.","%_yoast_wpseo_linkdex%":"75","%_wpgmp_location_address%":"Californi\u00eb, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Californi\u00eb","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.49766","%_wpgmp_metabox_longitude%":"-121.4206552","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_primary_category%":"172","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1677015041","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Lassen Volcanic National Park","taxonomy=post_tag":"Californi\u00eb","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png"},"id":11997,"infowindow_disable":false},{"source":"post","title":"Downtown Miami","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Downtown Miami\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/05/downtown-miami-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Downtown Miami</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"South Beach, Miami Beach, Florida 33139, Verenigde Staten","location":{"lat":"25.7826123","city":"Miami Beach","state":"Florida","country":"Verenigde Staten","lng":"-80.1340772","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/downtown-miami/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"25px\"][ultimate_heading main_heading=\"Downtown Miami\" heading_tag=\"span\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][ultimate_heading main_heading=\"Wat te doen in Downtown Miami\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:35px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:40px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]<strong>Downtown Miami wordt gezien als het centrum van de stad. Dit is de plek waar je grote musea, theaters, winkels en vele historische gebouwen vindt. Downtown Miami is samen met New York en Chicago een van de dichtstbevolkte binnensteden van Amerika. Je vindt er dus een afwisseling tussen bezienswaardigheden, vermaak, kantoren en huizen. Maar ook de prachtige stranden en palmbomen ontbreken niet in dit deel van de stad. Downtown Miami heeft alles! Tips voor bezienswaardigheden in Downtown Miami.</strong>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1640066907439{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"300px\"][vc_custom_heading text=\"Downtown Miami\" font_container=\"tag:div|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Palmbomen tussen de wolkenkrabbers\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"300px\"][parallax_row opacity=\"90\" enable_mobile=\"parallax-enable-mobile\" image=\"12077\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Downtown Miami - het centrum van de stad\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Downtown Miami is het oudste gedeelte van de stad. De skyline van de stad ken je misschien nog wel van de televisie serie CSI Miami. Hoewel je in Downtown ook veel appartementen en kantoren vindt, zijn er ook tal van bezienswaardigheden die je niet mag missen. Je kunt er goed winkelen, uit eten gaan, musea bezoeken en ook nog eens aan het strand liggen. Voor de meeste bezienswaardigheden moet je richting de waterkant van Downtown Miami.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][vc_custom_heading text=\"WAT TE DOEN IN DOWNTOWN MIAMI\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_row_inner css=\".vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"12075\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Bayside Market Place\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Om te winkelen of te dineren is Bayside Marketplace in Downtown Miami de plek. Het winkelcomplex in het centrum van de stad heeft uitzicht op de waterkant en jachthaven. In het twee verdiepingen tellende winkelcomplex vind je de bekende winkels en boetieks. Na het shoppen kun je bij de Bayside Marketplace terecht voor een drankje. Of wanneer je nog niet uitgekeken bent en het tegen etenstijd loopt, eten bij een van de vele populaire restaurants.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Downtown Miami | 401 Biscayne Blvd\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"12080\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Hobie Island Beach\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Even afkoelen na het shoppen of een museumbezoek? Daarvoor kun je terecht bij Hobie Beach. Hoewel het niet het mooiste strand is van Miami, kun je er terecht om even af te koelen en ondertussen te genieten van alle activiteit op het water. En mocht je zelf zin hebben, dan kun je ook een bootje huren om het water op te gaan.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Downtown Miami | Old Rickenbacker Causeway\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"12081\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Perez Museum\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In het museumpark van Miami vind je het Perez Museum. Er zijn meerdere redenen om dit museum aan je lijstje toe te voegen. Ten eerste valt het museumgebouw al op met zijn prachtige veranda's. Daarnaast heeft het een goede collectie hedendaagse kunt, met onder andere kunstwerken van Picasso in de collectie. En als laatste, er worden iedere maand diverse evenementen gehouden, bijvoorbeeld live muziek op vaste avonden.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Downtown Miami | 103 Biscayne Blvd\"][/vc_column_inner][/vc_row_inner][vc_row_inner css=\".vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"12085\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Freedom Tower\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een opvallend bouwwerk in de 'skyline' van Miami; de Freedom Tower of in het Spaans Torre de la Libertad. In het gebouw bevindt zich een kunstmuseum en verschillende kantoren. De Freedom Tower staat inmiddels op heel wat lijsten, zoals nationaal historisch monument. Het werd gezien als \"The Ellis Island\" van het zuiden, tussen 1962 en 1974 toen vele Cubanen richting Miami kwamen.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Downtown Miami | 600 Biscayne Blvd\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"12088\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Museum of Science\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Philip en Patricia Frost Museum of Science in Miami is een van de meest toonaangevende musea van de stad. Waarom? Je vindt er zowel een ultramodern planetarium als hypermodern aquarium. Er worden diverse tentoonstellingen rond het thema biodiversiteit, luchtvaart en de menselijke geest gepresenteerd. In het drie niveaus tellende aquarium vind je onder andere haaien pijlstaartroggen, tropische vissen en koraal, een hele onderwaterwereld![/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Downtown Miami | 1101 Biscayne Blvd\"][/vc_column_inner][vc_column_inner width=\"1/3\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" thb_row_padding=\"true\" thb_column_padding=\"true\" content_placement=\"middle\"][vc_column width=\"1/2\"][vc_row_inner][vc_column_inner width=\"5/6\"][heyusa_heading tag=\"div\" heading=\"Cruisen door Miami\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][vc_custom_heading text=\"Cruise langs miljonairshuizen in Miami\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een leuke manier om Downtown Miami te ontdekken is door aan boord te stappen van een <a href=\"https://www.getyourguide.com/downtown-miami-l5963/miami-boat-cruise-to-millionaires-row-and-venetian-islands-t395313/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=cruisemiljonairshuizendowntownintekst\" target=\"_blank\" rel=\"noopener\">cruise</a>. Met een luxe boot vaar je richting Star Island met prachtige herenhuizen, daarna wordt Biscayne Bay aangedaan. Hier kun je nog een glimp opvangen van het huis van Al Capone. Tijdens de cruise kom je langs andere beroemde Venetiaanse eilanden: Hibiscus Island, Palm Island, Sunset Island en Fischer Island.[/vc_column_text][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fdowntown-miami-l5963%2Fmiami-boat-cruise-to-millionaires-row-and-venetian-islands-t395313%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dcruisemiljonairshuizendowntown|title:Cruise%20Miami|target:_blank\" btn_size=\"ubtn-small\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:25px;\" btn_line_height=\"desktop:30px;\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][thb_image retina=\"retina_size\" full_width=\"true\" image=\"12091\"][/thb_image][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"75px\"][thb_postbackground source=\"post_type:post|by_id:9817\"][fullwidth_row content_width=\"100%\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"75px\"][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ontdek andere leuke wijken in Miami!\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][ultimate_heading main_heading=\"Bezoek andere wijken naast Downtown Miami\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:40px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:45px;\"][/ultimate_heading][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"25px\"][thb_postbackground style=\"style2\" source=\"by_id:12101,-12074,12063,11669,-1262,-2267,-883,-850,-572,-557,-545,-456,11771\"][/vc_column][/vc_row]","post_title":"Downtown Miami","post_link":"https://www.heyusa.com/nl/downtown-miami/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Downtown Miami\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/05/downtown-miami-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Miami","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1640066907439{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}.vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1685432286:2","%_edit_last%":"2","%_hide_featured%":null,"%_wpgmp_location_address%":"South Beach, Miami Beach, Florida 33139, Verenigde Staten","%_wpgmp_location_city%":"Miami Beach","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.7826123","%_wpgmp_metabox_longitude%":"-80.1340772","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Downtown Miami\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%inline_featured_image%":"0","%_yoast_wpseo_primary_category%":"167","%_thumbnail_id%":"12076","%standard-featured-credit%":"","%_yoast_wpseo_focuskw%":"Wat te doen in Downtown Miami","%_yoast_wpseo_metadesc%":"Wat te doen in Downtown Miami? Tips voor bezienswaardigheden in Downtown Miami om niet te missen tijdens je bezoek!","%_yoast_wpseo_linkdex%":"79","%thb-reactions-votes%":"1","%_yoast_wpseo_title%":"Wat te doen in %%title%% %%page%% %%sep%% %%sitename%%","%_yoast_indexnow_last_ping%":"1685432401","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Miami","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png"},"id":12074,"infowindow_disable":false},{"source":"post","title":"North Miami Beach","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"North Miami Beach\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/05/North-Beach-Miami-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">North Miami Beach</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"South Beach, Miami Beach, Florida 33139, Verenigde Staten","location":{"lat":"25.7826123","city":"Miami Beach","state":"Florida","country":"Verenigde Staten","lng":"-80.1340772","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/miami-north-beach/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"25px\"][ultimate_heading main_heading=\"North Miami Beach\" heading_tag=\"span\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][ultimate_heading main_heading=\"Wat te doen in North Miami Beach?\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:35px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_column_text]<strong>North Miami Beach is een wijk van de stad Miami Beach. Je vindt dit deel in het meest noordelijke stukje van de stad. De sfeer is relaxt en je ziet veel gebouwen in Miami Modernism architectuur terug in tegenstelling tot Miami Beach. Een van de grootste publiekstrekkers is het enorme strand waar het een stukje rustiger is. Benieuwd wat je in dit deel van Miami Beach kunt doen? Tips voor bezienswaardigheden in North Beach.</strong>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1640066907439{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"300px\"][vc_custom_heading text=\"Aventura Mall\" font_container=\"tag:div|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Shoppen, kunst en lekker eten in \u00e9\u00e9n\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"300px\"][parallax_row opacity=\"90\" enable_mobile=\"parallax-enable-mobile\" image=\"12069\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Miami North Beach - het rustige deel van Miami Beach\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">De naam North Beach verraadt het al, het strand speelt ook in dit deel van Miami een grote rol. Daarnaast is North Beach de plek om te golven, sportvissen of gebruik te maken van trendy eet-gelegenheden. De wijk biedt een breed scala aan activiteiten. Denk aan shoppen, actief zijn, de natuur in en lekker uit eten. Daardoor is North Beach een wijk voor iedereen, er is altijd wel iets leuks te doen!</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][vc_custom_heading text=\"WAT TE DOEN IN NORTH BEACH MIAMI\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_row_inner css=\".vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"12066\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Aventura Mall\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De plek om te shoppen in Miami is de Aventura Mall. Naast tal van leuke winkels is het ook een plek die je als niet-shop liefhebber kunt zien. De ruimtes zijn prachtig ontworpen, je kunt er kunst bekijken en lekker eten. Zo'n beetje alle kledingmerken die je kunt bedenken zitten in de mall. Denk aan luxe kledingmerken als\u00a0 Louis Vuitton, Cartier en Gucci, maar ook populaire retailers als Adidas, Apple, H&amp;M en Zara zitten in de Aventura Mall.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"North Beach | 19501 Biscayne Blvd\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"12067\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Oleta River State Park\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een van de fijnste plekken voor liefhebbers van de natuur in de buurt is het Oleta River State Park. Het park heeft een prachtig landschap en je kunt er verschillende dingen ondernemen zoals zwemmen, kajakken, fietsen en paddleboarden. De toegang aan het park is goedkoop, het ondernemen van activiteiten waar je apparatuur voor nodig hebt niet. En kom op tijd, want in tegenstelling tot vele andere parken hanteert het park vol is vol.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"North Beach | 3400 NE 163rd Street\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"12068\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Spanish Monastery\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een van de bekendste trekpleisters van North Beach is het Spaanse Klooster: Spanish Monastery. Dit klooster heeft een merkwaardige geschiedenis achter de rug. Het wordt ook wel de grootste, meest complexe en duurste legpuzzel ter wereld genoemd. Het werd begin 12e eeuw gebouwd en gebruikt in Spanje waarvoor het bedoelt was, een klooster. In 1920 werd het gebouw gekocht door William Randolph Hears, de krantenmagnaat. Hij verscheepte het klooster naar Miami, een dure en ingewikkelde operatie.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"North Beach | 16711 W. Dixie Highway\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][thb_postbackground source=\"post_type:post|by_id:9817\"][fullwidth_row content_width=\"100%\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"75px\"][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ontdek andere leuke wijken in Miami!\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][ultimate_heading main_heading=\"Bezoek andere wijken naast Miami North Beach\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:40px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:45px;\"][/ultimate_heading][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"25px\"][thb_postbackground style=\"style2\" source=\"by_id:12101,12074,-12063,11669,-1262,-2267,-883,-850,-572,-557,-545,-456,11771\"][/vc_column][/vc_row]","post_title":"North Miami Beach","post_link":"https://www.heyusa.com/nl/miami-north-beach/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"North Miami Beach\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/05/North-Beach-Miami-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Miami","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1640066907439{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1685432284:2","%_edit_last%":"2","%_hide_featured%":null,"%_wpgmp_location_address%":"South Beach, Miami Beach, Florida 33139, Verenigde Staten","%_wpgmp_location_city%":"Miami Beach","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.7826123","%_wpgmp_metabox_longitude%":"-80.1340772","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"North Beach\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%inline_featured_image%":"0","%_yoast_wpseo_primary_category%":"167","%_thumbnail_id%":"12070","%standard-featured-credit%":"","%_yoast_wpseo_focuskw%":"North Miami Beach","%_yoast_wpseo_metadesc%":"Wat te doen in South Beach Miami? Tips voor bezienswaardigheden in South Beach Miami om niet te missen tijdens je bezoek!","%_yoast_wpseo_linkdex%":"78","%thb-reactions-votes%":"1","%_yoast_indexnow_last_ping%":"1685431755","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Miami","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png"},"id":12063,"infowindow_disable":false},{"source":"post","title":"Broadway District Tour","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Broadway\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/05/Broadway-1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Broadway District Tour</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"245 W 44th St, New York, NY 10036, Verenigde Staten","location":{"lat":"40.7583598","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.98807910000001","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/broadway-district-tour/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Broadway District Tour\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ult_buttons btn_title=\"BESTEL TICKETS\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fbroadway-theatre-district-tour-t72309%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26utm_source%3Dnwyrk_media%26placement%3Dbroadwaydistricttourboven|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#000000\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_column_text]Tijdens deze <a href=\"https://www.getyourguide.com/new-york-city-l59/broadway-theatre-district-tour-t72309/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;utm_source=nwyrk_media&amp;placement=content-middle\" target=\"_blank\" rel=\"noopener noreferrer\">twee uur durende rondleiding</a> met een offici\u00eble New York gids verken je Times Square, 42nd Street en verschillende filmlocaties in New York. Bekijk enkele Broadway theaters van binnen en hoor insider geheimen vanuit de theaterwereld. Ideaal voor Broadway- en filmfans die meer te weten willen komen over het gebied rond Times Square.[/vc_column_text][vc_custom_heading text=\"Handige informatie voor Broadway District Tour in New York\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<b>Duur:</b><span style=\"font-weight: 400;\"> 2 uur</span><span style=\"font-weight: 400;\">\r\n</span><b>Prijs</b><span style=\"font-weight: 400;\">: Vanaf 33 euro</span><span style=\"font-weight: 400;\">\r\n</span><b>Vertreklocatie</b><span style=\"font-weight: 400;\">: Majestic Theatre (Home of Phantom of the Opera)</span><span style=\"font-weight: 400;\">\r\n</span><b>Openingstijden:</b> Dagelijks om onder andere 15:30 uur[/vc_column_text][ult_buttons btn_title=\"BESTEL TICKETS\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fbroadway-theatre-district-tour-t72309%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26utm_source%3Dnwyrk_media%26placement%3Dbroadwaydistricttouronder|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#000000\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][vc_empty_space height=\"20px\"][/vc_column][vc_column width=\"1/3\"][thb_image retina=\"retina_size\" box_shadow=\"medium-shadow\" thb_border_radius=\"10px\" image=\"3436\"][/thb_image][vc_empty_space height=\"20px\"][vc_column_text][/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"size:4|post_type:post|by_id:506,6279,1767,1484\"][/vc_column][/vc_row]","post_title":"Broadway District Tour","post_link":"https://www.heyusa.com/nl/broadway-district-tour/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Broadway\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/05/Broadway-1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden New York","post_tags":"","%_edit_last%":"1","%_edit_lock%":"1668001330:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"14","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style3","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":{"2":{"title":"","post_source_url":""}},"%_yoast_wpseo_focuskw%":"The Ride New York","%_yoast_wpseo_metadesc%":"Stap in The Ride voor een onvergetelijke entertainment experience in New York. Deels theatershow, deels stadstour in NYC, een unieke ervaring.","%_yoast_wpseo_linkdex%":"40","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Fietsen Miami\"]","%_wpgmp_location_address%":"245 W 44th St, New York, NY 10036, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7583598","%_wpgmp_metabox_longitude%":"-73.98807910000001","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"1805","%inline_featured_image%":"0","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"14","%_wp_old_date%":"2022-05-04","%_wp_desired_post_slug%":"the-ride-nyc","%_yoast_indexnow_last_ping%":"1677015056","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Bezienswaardigheden New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":11915,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"The Ride NYC","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Ride\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/05/the-ride-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">The Ride NYC</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"259 W 42nd St, New York, NY 10036, In Front of Patrick's Restaurant, New York, NY 10018, Verenigde Staten","location":{"lat":"40.75720949999999","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.98933099999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/the-ride-nyc/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"The Ride New York\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_column_text]Je hebt hem vast wel eens zien rijden in New York, een opvallende bus met daarop de letters The Ride. Met deze bus maak je een onvergetelijke rit door de straten van New York City. Je ervaart met The Ride levendige kunst en cultuur tijdens je rit. In een stadion opstelling rijd je langs locaties als Central Park of Times Square om allerlei straatoptredens te zien. <a href=\"https://www.getyourguide.com/new-york-city-l59/nyc-the-ride-experience-ticket-t265117/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=content-middle&amp;cmp=therideintekst\" target=\"_blank\" rel=\"noopener\">The Ride</a> is een unieke entertainment ervaring in Broadway stijl.\r\n<h3>Leuke facts over The Ride</h3>\r\n<ul>\r\n \t<li>Al meer dan 1 miljoen keer gereden (2020)</li>\r\n \t<li>Meer dan 27.000 performances (2022)</li>\r\n \t<li>Er werken meer dan 150 mensen om The Ride te laten rijden ieder jaar</li>\r\n \t<li>Er worden meer dan 3000 LED Lights en 40 video screens worden er gebruikt</li>\r\n</ul>\r\n[/vc_column_text][vc_custom_heading text=\"Handige informatie voor The Ride in New York\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<b>Duur:</b><span style=\"font-weight: 400;\"> 75 minuten</span><span style=\"font-weight: 400;\">\r\n</span><b>Prijs</b><span style=\"font-weight: 400;\">: Vanaf 75 euro</span><span style=\"font-weight: 400;\">\r\n</span><b>Vertreklocatie</b><span style=\"font-weight: 400;\">: Patrick's Restaurant in Midtown Manhattan</span><span style=\"font-weight: 400;\">\r\n</span><b>Openingstijden:</b> Dagelijks om onder andere 16:30 uur, 18:00 uur en 19:30 uur[/vc_column_text][ultimate_heading main_heading=\"The Ride is onderdeel van de New York Sightseeing Pass\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][vc_empty_space height=\"20px\"][ult_buttons btn_title=\"Bekijk de New York Sightseeing Pass\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fvoordeelpassen-new-york%2F|title:Bekijk%20de%20New%20York%20Sightseeing%20Pass|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"20px\"][/vc_column][vc_column width=\"1/3\"][thb_image retina=\"retina_size\" box_shadow=\"medium-shadow\" thb_border_radius=\"10px\" image=\"11900\"][/thb_image][vc_empty_space height=\"20px\"][vc_column_text][/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"size:4|post_type:post|by_id:506,6279,1767,1484\"][/vc_column][/vc_row]","post_title":"The Ride NYC","post_link":"https://www.heyusa.com/nl/the-ride-nyc/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Ride\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/05/the-ride-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden New York","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1690449000:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"168","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style3","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":{"2":{"title":"","post_source_url":""}},"%_yoast_wpseo_focuskw%":"The Ride New York","%_yoast_wpseo_metadesc%":"Stap in The Ride voor een onvergetelijke entertainment experience in New York. Deels theatershow, deels stadstour in NYC, een unieke ervaring.","%_yoast_wpseo_linkdex%":"54","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Fietsen Miami\"]","%_wpgmp_location_address%":"259 W 42nd St, New York, NY 10036, In Front of Patrick's Restaurant, New York, NY 10018, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.75720949999999","%_wpgmp_metabox_longitude%":"-73.98933099999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_thumbnail_id%":"11901","%inline_featured_image%":"0","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"14","%_wp_old_date%":"2022-05-04","%_wp_desired_post_slug%":"the-ride-nyc","%_yoast_indexnow_last_ping%":"1690449001","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Bezienswaardigheden New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":11899,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Madame Tussauds in New York","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Madame Tussauds\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/05/madame-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Madame Tussauds in New York</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"234 W 42nd St, New York, NY 10036, Verenigde Staten","location":{"lat":"40.7564269","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.9888338","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/madame-tussauds-in-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Madame Tussauds in New York bezoeken\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">De plek om beroemdheden te spotten is natuurlijk bij Madame Tussauds in New York. Niet de echte helaas, hoewel je die op de straten van New York ook tegen kunt komen, maar hun wassen versie. Toch blijft Madame Tussauds een leuke activiteit voor jong en oud. Check hoeveel beroemdheden jij kent bij Madame Tussauds en bestel alvast je <a href=\"https://www.getyourguide.com/new-york-city-l59/new-york-city-madame-tussauds-ticket-t205264/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=content-top&amp;cmp=madametussaudsnycintrotekst\" target=\"_blank\" rel=\"noopener\">tickets online</a>!</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf <span class=\"sticky-booking-assistant__price\" data-v-35e2752c=\"\">\u20ac43</span>[/ultimate_icon_list_item][/ultimate_icon_list][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fnew-york-city-madame-tussauds-ticket-t205264%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3Dcontent-top%26cmp%3Dmadametussaudsnycboven|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612949537564{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Madame Tussauds\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Op meer dan 5 verdiepingen midden op Times Square vind je tal van beroemdheden, wassen beroemdheden wel te verstaan. Sinds 2000 is Madame Tussauds een leuke activiteit voor het hele gezin in New York. Ooit bedacht door Maria Tussaud, een Fran\u00e7aise die in 1778 haar eerste beeld maakte. Een aantal jaren later werden haar wassen beelden tentoongesteld in Engeland. Nadat ze overleed besloten haar twee zoons haar tentoonstelling in 1884 te verhuizen naar Madame Tussauds in Londen, de locatie van het huidige museum. Sinds de opening in London zijn er meer dan 25 vestigingen van Madame Tussauds geopend wereldwijd.</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Deze ruimtes mag je niet missen in Madame Tussauds in New York\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"16920\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Marvel\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">In Madame Tussauds vind je een eerbetoon aan Marvel. Ontmoet superhelden zoals Thor, Captain America, de Hulk of Spiderman en ga met ze op de foto. Tegen betaling kun je een korte film bekijken met 4D special effects. Een unieke ervaring, het lijkt net alsof je meedoet aan de film in plaats van alleen aan het kijken bent.\u00a0</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"16930\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Beroemdheden\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Voor elke generatie zijn er supersterren te vinden; denk aan Marilyn Monroe, Madonna of Lady Gaga. De ultieme mogelijkheid om met je icoon op de foto te gaan. Naast de wassenbeelden is Madame Tussauds ook nog interactief. Je kunt piano spelen met Alicia Keys, naast Jimmy Fallon plaatsnemen voor de Tonight Show en over de catwalk van de NY Fashion week lopen.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"11862\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"De wereld van films en tv series\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Natuurlijk speelt film een belangrijke rol in de wereld van beroemdheden. Films, maar ook acteurs en actrices zijn ruim vertegenwoordigd in Madame Tussauds. Denk aan de film Ghostbusters waarbij je op zoek gaat naar paranormale wezens of King Kong waarbij een levensgrote King Kong natuurlijk niet kan ontbreken.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Spot verschillende popsterren\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ga op de foto met The Beatles\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"11861\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tickets voor Madame Tussauds\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Voor je bezoek aan Madame Tussauds kun je <a href=\"https://www.getyourguide.com/new-york-city-l59/new-york-city-madame-tussauds-ticket-t205264/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=content-top&amp;cmp=madametussaudsnyctekstticket\" target=\"_blank\" rel=\"noopener\">online een ticket aanschaffen</a>. Zo heb je gegarandeerd toegang tot het museum.\r\n\r\nMadame Tussauds is gevestigd om de hoek van Times Square waardoor het makkelijk te bereiken is met de metro.[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fnew-york-city-madame-tussauds-ticket-t205264%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3Dcontent-top%26cmp%3Dmadametussaudsnyconder|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"1/2\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>234 West 42nd Street</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Maandag, dinsdag, woensdag, donderdag en zondag: 10.00 tot 20.00 uur\r\nVrijdag en zaterdag: 10.00 tot 22.00 uur</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"President van Amerika\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Joe Biden en Kamala Harris in Madame Tussauds\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"16921\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1620887540936{background-color: #dadada !important;}\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][ultimate_heading main_heading=\"Veelgestelde vragen over Madame Tussauds\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:800;\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][vc_toggle title=\"Wat kost een ticket voor Madame Tussauds\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]Je hebt tickets vanaf 43 euro. Madame Tussauds zit bij sommige voordeelpassen inbegrepen.[/vc_toggle][vc_toggle title=\"Wat is de beste tijd om Madame Tussauds te bezoeken?\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]De beste tijd om Madame Tussauds te bezoeken is in de vroege morgen. Op dat tijdstip is het rustiger dan midden op de dag.[/vc_toggle][vc_toggle title=\"Hoe lang duurt een bezoek aan Madame Tussauds?\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]Je bent ongeveer 1,5 tot 2 uur kwijt voor een bezoek aan Madame Tussauds[/vc_toggle][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"80%\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:10251,1559,506,298\"][/vc_column][/vc_row]","post_title":"Madame Tussauds in New York","post_link":"https://www.heyusa.com/nl/madame-tussauds-in-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Madame Tussauds\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/05/madame-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1612949537564{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1620887540936{background-color: #dadada !important;}","%inline_featured_image%":"0","%_edit_last%":"2","%_edit_lock%":"1690819000:1","%_wpb_vc_js_status%":"true","%post-primary-category%":"14","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"11863","%_yoast_wpseo_focuskw%":"Madame Tussauds in New York","%_yoast_wpseo_title%":"Madame Tussauds in New York%%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een leuke attractie is Madame Tussauds in New York. Het wassenbeelden museum is de plek om beroemdheden te spotten en selfies te maken. Koop hier je tickets.","%_yoast_wpseo_linkdex%":"77","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Tickets Madame Tussauds\"]","%_wpgmp_location_address%":"234 W 42nd St, New York, NY 10036, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7564269","%_wpgmp_metabox_longitude%":"-73.9888338","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_primary_category%":"14","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1690806101","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","%post_via%":[{"title":"Foto's \u00a9 Madame Tussauds (Madame Tussauds USA) /  Merlin Entertainments Ltd","post_source_url":"https://www.madametussauds.com/"}],"taxonomy=category":"Bezienswaardigheden New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":11859,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"The Strip","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Strip\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/04/the-strip-las-vegas-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">The Strip</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"South Beach, Miami Beach, Florida 33139, Verenigde Staten","location":{"lat":"25.7826123","city":"Miami Beach","state":"Florida","country":"Verenigde Staten","lng":"-80.1340772","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/las-vegas/the-strip-las-vegas/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"25px\"][ultimate_heading main_heading=\"The Strip\" heading_tag=\"span\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][ultimate_heading main_heading=\"Wat te doen op The Strip\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:35px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_column_text]<strong>De Las Vegas Strip of in de volksmond ook wel The Strip, is een van de meest bekende bezienswaardigheden om te bezoeken in Las Vegas. Hier gebeurt alles in Las Vegas, het epicentrum van de stad. De bijna 7 kilometer lange Las Vegas Boulevard is de plek waar vele bezienswaardigheden, hotels, casino's, restaurants en winkels gevestigd zijn. Het is de meest bekende en meest bezochte straat van Las Vegas. Tips voor een bezoek aan The Strip in Las Vegas.</strong>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1640066907439{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"300px\"][vc_custom_heading text=\"The Strip\" font_container=\"tag:div|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Populairste straat Las Vegas\" font_container=\"tag:div|font_size:35|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"300px\"][parallax_row opacity=\"90\" enable_mobile=\"parallax-enable-mobile\" image=\"3749\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Epicentrum Las Vegas\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Bij een bezoek aan Las Vegas kun je eigenlijk niet om The Strip heen. Het is het epicentrum van de stad, de plek waar alles plaatsvindt. Waar casino's, hotels, winkels en restaurants elkaar letterlijk opvolgen. Waar je je dagen kunt vermaken zonder dat je de stad hoeft te verlaten. Tijdens een bezoek aan Las Vegas kun je in \u00e9\u00e9n van de vele (thema) hotels aan The Strip overnachten, hotels inclusief restaurants, casino's en shopping malls. Hier vind je 15 van de 25 grootste hotels ter wereld. Laat je onderdompelen in alle entertainment aan The Strip.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][vc_custom_heading text=\"WAT TE DOEN OP THE STRIP IN LAS VEGAS\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_row_inner disable_element=\"yes\" css=\".vc_custom_1651149408706{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"11772\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Calle Ocho\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het centrum van Little Havana is de straat Calle Ocho. De plek waar je het Cubaanse leven en cultuur het beste kunt ondervinden in Miami. Inmiddels uitgeroepen tot National Treasure door de National Trust for Historic Preservation, is dit de plek waar je Cubaanse restaurants, sigaren winkels, Cubaanse bakkerijen en Domino Park vindt.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Little Havana | Calle Ocho\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"11774\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Walk of fame\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Miami heeft zijn eigen Walk of Fame. Op de Calle Ocho vind je de Walk of Fame van Miami waar je alleen Latino sterren kunt vinden die een band hebben met Florida. In 1987 werd de eerste ster geplaatst voor Celia Cruz, de beroemde salsa zangeres. Inmiddels zijn er zo'n 30 andere beroemdheden te vinden op de Walk of Fame. Je vindt de Walk of Fame tussen 12th en 17th Avenue.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Little Havana | Calle Ocho - 12th &amp; 17th Avenue\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"11750\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Domino Park\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Domino Park is het verzamelpunt voor de inwoners van Little Havana. Hier komen ze bij elkaar om Cubaanse koffie te drinken, domino te spelen en te kletsen met anderen. Het spelen van domino is een traditie van meer dan 40 jaar oud. Het spel wordt serieus genomen en is alleen voor leden. Publiek vinden ze overigens niet erg, dus kijk gerust mee tijdens een potje domino. Naast dominospelers vind je in Domino Park diverse versierde tegelwerken met dominostenen en een muurschildering van de Dominicaanse kunstenaar Oscar Thomas.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Little Havana | 801 SW 15th Ave\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][thb_blockgrid style=\"style5\" source=\"size:10|post_type:post|by_id:4434,4317,3660,2398,2391\"][thb_blockgrid style=\"style5\" source=\"size:10|post_type:post|by_id:14660,14406,12584\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][thb_postbackground source=\"post_type:post|by_id:5897\"][fullwidth_row content_width=\"100%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1606171128628{padding-top: 75px !important;padding-bottom: 75px !important;}\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"25px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][vc_custom_heading text=\"In de buurt van The Strip:\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][thb_postgrid style=\"style4\" columns=\"4\" source=\"post_type:post|by_id:11382,10505,4460,2396\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row]","post_title":"The Strip","post_link":"https://www.heyusa.com/nl/las-vegas/the-strip-las-vegas/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Strip\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/04/the-strip-las-vegas-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Las Vegas","post_tags":"Nevada","%_wpb_shortcodes_custom_css%":".vc_custom_1640066907439{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1606171128628{padding-top: 75px !important;padding-bottom: 75px !important;}.vc_custom_1651149408706{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1676030269:2","%_edit_last%":"1","%_hide_featured%":null,"%_wpgmp_location_address%":"South Beach, Miami Beach, Florida 33139, Verenigde Staten","%_wpgmp_location_city%":"Miami Beach","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.7826123","%_wpgmp_metabox_longitude%":"-80.1340772","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"The Strip\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%inline_featured_image%":"0","%_yoast_wpseo_primary_category%":"53","%_thumbnail_id%":"11790","%standard-featured-credit%":"","%_yoast_wpseo_focuskw%":"The Strip Las Vegas","%_yoast_wpseo_metadesc%":"Wat te doen aan The Strip in Las Vegas ? Tips voor bezienswaardigheden op The Strip om niet te missen tijdens je bezoek!","%_yoast_wpseo_linkdex%":"74","%thb-reactions-votes%":"1","%_last_editor_used_jetpack%":"classic-editor","%_yoast_indexnow_last_ping%":"1677015081","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Las Vegas","taxonomy=post_tag":"Nevada","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png"},"id":11787,"infowindow_disable":false},{"source":"post","title":"Little Havana","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Little Havana\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/04/little-havana-wijk-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Little Havana</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"South Beach, Miami Beach, Florida 33139, Verenigde Staten","location":{"lat":"25.7826123","city":"Miami Beach","state":"Florida","country":"Verenigde Staten","lng":"-80.1340772","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/miami/little-havana/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"25px\"][ultimate_heading main_heading=\"Little Havana\" heading_tag=\"span\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][ultimate_heading main_heading=\"Wat te doen in Little Havana?\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:35px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_column_text]<strong>Waan je in de Cubaanse sferen in de wijk Little Havana in Miami. Vernoemd naar de Cubaanse hoofdstad, staat Little Havana bekend om vele politieke, culturele en sociale activiteiten in Miami. Ieder jaar zijn er tal van festivals in de wijk die de moeite waard zijn om te bezoeken. In Little Havana vind je genoeg leuke bezienswaardigheden die de moeite waard zijn om te bezoeken en ontdek daarnaast de Cubaanse cultuur in de wijk tijdens een wandeltour.\u00a0</strong>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1640066907439{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"300px\"][vc_custom_heading text=\"Little Havana\" font_container=\"tag:div|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Wijk vol Cubaanse inlvloeden\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"300px\"][parallax_row opacity=\"90\" enable_mobile=\"parallax-enable-mobile\" image=\"11773\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Cubaanse sferen in Little Havana\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Little Havana is de bekendste Cubaanse ballingschapswijk ter wereld. Je vindt hier nog vele Cubaanse invloeden terug in het straatleven, restaurants, muziek en vele culturele activiteiten. De beste manier om je onder te dompelen in de Cubaanse cultuur is via eten. Proef Cubaanse koffie, een Cubaanse sandwich, empanada's of ijs van Azucar Ice Cream Company. Wandel door de wijk en sluit je dag af met een mojito bij een van de vele restaurants.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][vc_custom_heading text=\"Wat te doen in Little Havana\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_row_inner css=\".vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"11772\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Calle Ocho\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het centrum van Little Havana is de straat Calle Ocho. De plek waar je het Cubaanse leven en cultuur het beste kunt ondervinden in Miami. Inmiddels uitgeroepen tot National Treasure door de National Trust for Historic Preservation, is dit de plek waar je Cubaanse restaurants, sigaren winkels, Cubaanse bakkerijen en Domino Park vindt.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Little Havana | Calle Ocho\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"11774\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Walk of fame\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Miami heeft zijn eigen Walk of Fame. Op de Calle Ocho vind je de Walk of Fame van Miami waar je alleen Latino sterren kunt vinden die een band hebben met Florida. In 1987 werd de eerste ster geplaatst voor Celia Cruz, de beroemde salsa zangeres. Inmiddels zijn er zo'n 30 andere beroemdheden te vinden op de Walk of Fame. Je vindt de Walk of Fame tussen 12th en 17th Avenue.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Little Havana | Calle Ocho - 12th &amp; 17th Avenue\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"11750\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Domino Park\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Domino Park is het verzamelpunt voor de inwoners van de wijk. Hier komen ze bij elkaar om Cubaanse koffie te drinken, domino te spelen en te kletsen met anderen. Het spelen van domino is een traditie van meer dan 40 jaar oud. Het spel wordt serieus genomen en is alleen voor leden. Publiek vinden ze overigens niet erg, dus kijk gerust mee tijdens een potje domino. Naast dominospelers vind je in Domino Park diverse versierde tegelwerken met dominostenen en een muurschildering van de Dominicaanse kunstenaar Oscar Thomas.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Little Havana | 801 SW 15th Ave\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][thb_blockgrid style=\"style2\" source=\"size:10|post_type:post|by_id:11752,11748\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][thb_postbackground source=\"post_type:post|by_id:9817\"][fullwidth_row content_width=\"100%\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"75px\"][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ontdek andere leuke wijken in Miami!\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][ultimate_heading main_heading=\"Bezoek andere wijken naast Little Havana\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:40px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:45px;\" margin_design_tab_text=\"\"][/ultimate_heading][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"25px\"][thb_postbackground style=\"style2\" source=\"by_id:-1262,-2267,-883,-850,-572,-557,-545,-456,11669,12101,12074,12063\"][/vc_column][/vc_row]","post_title":"Little Havana","post_link":"https://www.heyusa.com/nl/miami/little-havana/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Little Havana\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/04/little-havana-wijk-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Miami","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1640066907439{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1685432923:2","%_edit_last%":"2","%_hide_featured%":null,"%_wpgmp_location_address%":"South Beach, Miami Beach, Florida 33139, Verenigde Staten","%_wpgmp_location_city%":"Miami Beach","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.7826123","%_wpgmp_metabox_longitude%":"-80.1340772","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Little Havana Miami\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%inline_featured_image%":"0","%_yoast_wpseo_primary_category%":"167","%_thumbnail_id%":"11754","%standard-featured-credit%":"","%_yoast_wpseo_focuskw%":"Little Havana","%_yoast_wpseo_metadesc%":"Wat te doen in Little Havana Miami? Tips voor bezienswaardigheden in Little Havana Miami om niet te missen tijdens je bezoek!","%_yoast_wpseo_linkdex%":"71","%thb-reactions-votes%":"1","%_yoast_indexnow_last_ping%":"1685431978","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Miami","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png"},"id":11771,"infowindow_disable":false},{"source":"post","title":"Rondleiding Little Havana","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Little Havana\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/04/little-havana-miami1.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Rondleiding Little Havana</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1305 SW 8th St, Miami, FL 33135, Verenigde Staten","location":{"lat":"25.7660042","city":"Miami","state":"Florida","country":"Verenigde Staten","lng":"-80.216402","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/little-havana-wandeltour-miami/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Little Havana rondleiding\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_column_text]Little Havana is een van de meest cultureel rijke wijken in Miami. Ga met de wandeltour door Little Havana mee en kom meer te weten over de geschiedenis van de wijk, zijn inwoners en tradities. Ontdek de populaire plekken en gebieden met restaurants, bars en bezienswaardigheden. Natuurlijk kan een kijkje in de Cubaanse keuken niet ontbreken. Ook de dominospelers, Calle Ocho en de Cubaanse sigaren ontbreken niet tijdens deze wandeltour door Little Havana.[/vc_column_text][vc_custom_heading text=\"Handige informatie voor de rondleiding door Little Havana\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<b>Duur:</b><span style=\"font-weight: 400;\"> 2 uur en 15 minuten</span><span style=\"font-weight: 400;\">\r\n</span><b>Prijs</b><span style=\"font-weight: 400;\">: Vanaf 37 euro</span><span style=\"font-weight: 400;\">\r\n</span><b>Vertreklocatie</b><span style=\"font-weight: 400;\">: 1305 SW 8th St</span><span style=\"font-weight: 400;\">\r\n</span><b>Openingstijden:</b> Dagelijks om 10.00 uur[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.viator.com%2Ftours%2FMiami%2FLittle-Havana-Introductory-Tour%2Fd662-51540P4%3Fpid%3DP00074479%26mcid%3D42383%26medium%3Dlink%26campaign%3Dwandeltourlittlehavana|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"20px\"][/vc_column][vc_column width=\"1/3\"][thb_image retina=\"retina_size\" box_shadow=\"medium-shadow\" thb_border_radius=\"10px\" image=\"11753\"][/thb_image][vc_empty_space height=\"20px\"][vc_column_text][/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Miami\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"size:4|post_type:post|categories:168\"][/vc_column][/vc_row]","post_title":"Rondleiding Little Havana","post_link":"https://www.heyusa.com/nl/little-havana-wandeltour-miami/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Little Havana\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/04/little-havana-miami1.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Miami","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1685443699:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"168","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style3","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":{"2":{"title":"","post_source_url":""}},"%_yoast_wpseo_focuskw%":"Rondleiding Little Havana","%_yoast_wpseo_metadesc%":"Ontdek de levendige cultuur van de wijk Little Havana in Miami. Ga mee op een wandeltour door Little Havana en ontdek de geheimen van de wijk.","%_yoast_wpseo_linkdex%":"54","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Wandeltour Little Havana\"]","%_wpgmp_location_address%":"1305 SW 8th St, Miami, FL 33135, Verenigde Staten","%_wpgmp_location_city%":"Miami","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.7660042","%_wpgmp_metabox_longitude%":"-80.216402","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"11773","%inline_featured_image%":"0","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"168","%_yoast_indexnow_last_ping%":"1685435497","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Bezienswaardigheden Miami","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":11752,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Little Havana Foodtour","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Little Havana\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/04/little-havana-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Little Havana Foodtour</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1508 SW 8th St, Miami, FL 33135, Verenigde Staten","location":{"lat":"25.7654353","city":"Miami","state":"Florida","country":"Verenigde Staten","lng":"-80.2196728","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/little-havana-foodtour-miami/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Little Havana Foodtour\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_column_text]Met deze <a href=\"https://www.getyourguide.com/miami-l176/little-havana-food-cultural-walking-tour-with-lunch-t392437/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=littlehavanafoodtour\" target=\"_blank\" rel=\"noopener\">Little Havana Foodtour</a>\u00a0ontdek en beleef de levendige wijk Little Havana in Miami. Bekijk welke culturele tradities er zijn, welke bezienswaardigheden en hoor de verhalen van de inwoners van de wijk. Onderweg kun je Cubaanse gerechten proberen die al jarenlang op dezelfde manier worden gemaakt. Ontmoet de lokale bevolking, bezoek verschillende spirituele plekken en kom meer te weten over geheime religieuze praktijken. Kijk hoe de inwoners domino spelen op Domino Plaza, leer hoe sigaren worden gerold en proef vers gezette Cubaanse koffie.[/vc_column_text][vc_custom_heading text=\"Handige informatie voor de foodtour door Little Havana\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<b>Duur:</b><span style=\"font-weight: 400;\"> 2 uur en 30 minuten</span><span style=\"font-weight: 400;\">\r\n</span><b>Prijs</b><span style=\"font-weight: 400;\">: Vanaf 65 euro</span><span style=\"font-weight: 400;\">\r\n</span><b>Vertreklocatie</b><span style=\"font-weight: 400;\">: Tower Theater op 1508 SW 8th St</span><span style=\"font-weight: 400;\">\r\n</span><b>Openingstijden:</b> Dagelijks om 11:30 uur en 12.30 uur[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fmiami-l176%2Flittle-havana-food-cultural-walking-tour-with-lunch-t392437%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dlittlehavanafoodtour|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"20px\"][/vc_column][vc_column width=\"1/3\"][thb_image retina=\"retina_size\" box_shadow=\"medium-shadow\" thb_border_radius=\"10px\" image=\"11750\"][/thb_image][vc_empty_space height=\"20px\"][vc_column_text][/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Miami\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"size:4|post_type:post|categories:168\"][/vc_column][/vc_row]","post_title":"Little Havana Foodtour","post_link":"https://www.heyusa.com/nl/little-havana-foodtour-miami/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Little Havana\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/04/little-havana-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Miami","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1685444721:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"168","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style3","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":{"2":{"title":"","post_source_url":""}},"%_yoast_wpseo_focuskw%":"Little Havana Foodtour","%_yoast_wpseo_metadesc%":"Ontdek de levendige cultuur van de wijk Little Havana in Miami. Ga mee op een foodtour door Little Havana en ontdek de keuken en de wijk.","%_yoast_wpseo_linkdex%":"66","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Food Litte Havana\"]","%_wpgmp_location_address%":"1508 SW 8th St, Miami, FL 33135, Verenigde Staten","%_wpgmp_location_city%":"Miami","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.7654353","%_wpgmp_metabox_longitude%":"-80.2196728","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"11749","%inline_featured_image%":"0","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"168","%_yoast_indexnow_last_ping%":"1685444735","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Bezienswaardigheden Miami","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":11748,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Biscayne National Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Biscayne National Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/04/mangrove-biscayne-np-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Biscayne National Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Florida, Verenigde Staten","location":{"lat":"25.4824229","state":"Florida","country":"Verenigde Staten","lng":"-80.20831030000001","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/biscayne-national-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Biscayne National Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Ten oosten van de Everglades vind je het Biscayne National Park, of eigenlijk de 5% van het park die maar boven water ligt. Biscayne National Park bestaat namelijk voor 95% uit water. Valt er dan wel genoeg te zien in Biscayne National Park? Ja zeker, het park is een prachtig natuurgebied om op het water of onder water te verkennen. Ga duiken of snorkelen bij de koraalriffen of stap in een boot om de unieke natuur van Biscayne National Park te ontdekken.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]65 kilometer van Miami - bereikbaar per boot[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">700 km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-paw\"]16 bedreigde diersoorten[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-leaf\"]<span class=\"LrzXr kno-fv\">meer dan 350 verschillende soorten bomen en planten</span>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Vier verschillende ecosystemen in natuurgebied\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Met een oppervlakte van 700km\u00b2 bestaat Biscayne National Park voor 95% uit water. Het natuurgebied dat sinds 1980 een nationaal park is, kent vier verschillende ecosystemen. Zo is er een strook mangrove bos, het zuidelijke deel van Biscayne Bay, de noordelijke eilanden van de Florida Keys en het op twee na grootste koraalrif van de wereld. Door deze vier verschillende ecosystemen, is het een prachtig gebied voor verschillende dieren. Je kunt er onder andere 200 soorten vissen, 16 bedreigde diersoorten, zeekoeien, zeeschildpadden, krokodillen, alligators en walvissen zien.</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Stilstville\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Zeven huisjes op palen in Biscayne National Park\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"11511\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Facts Biscayne National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Hoewel Biscayne National Park pas in 1980 een nationaal park werd, waren er bij de oprichting van <a href=\"https://www.heyusa.com/nl/everglades-national-park/\">Everglades National Park</a> in 1947 al plannen voor het gebied. Echter werden onder andere Biscayne Bay en Key Largo uit het Everglades National Park gesneden. In 1960 werd een tweede poging gedaan om van het natuurgebied een nationaal park te maken, de uitslag van het onderzoek waren gunstig. President Lyndon B. Johnson tekende in 1968 een law om Biscayne National Monument te cre\u00ebren. De law werd in de jaren erna nog meerdere malen uitgebreid tot Biscayne National Park in 1980 de status van nationaal park kreeg.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Hoogtepunten in Biscayne National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Biscayne National Park bestaat uit vier verschillende ecosystemen en is daardoor een perfecte plek om wildlife te spotten. Aan de kuststrook van 14 mijl ligt een mangrovebos dat redelijk ondoordringbaar is. Het Dante Facell Visitor Center is het hele jaar geopend en de plek om meer te weten te komen over deze vier verschillende ecosystemen. Een hoogtepunt om niet te missen is Biscayne Bay. De grote, heldere baai ligt deels in het park en deels in andere State Parks. In de baai worden zoet en zout water met elkaar gemengd, het is er meestal tussen de 1-3 meter diep en door de warme Golfstroom is het een goede plek voor koraalriffen. Hierdoor zwemmen er talrijke tropische vissen. Een andere leuke bezienswaardigheid is Stiltsville waar je zeven op palen gebouwde huizen vindt op het water.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten in het Biscayne National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Overnachten in het park kan op twee campings. De campgrounds liggen op de eilanden Elliot Key en Boca Chita Key. Je kunt deze plekken alleen per boot bezoeken. Boca Chita Key is het meest populaire eiland, de uitzichten vanuit je tent zijn niet verkeerd. Qua faciliteiten zijn er picknicktafels, grillplaten en toiletten. Er zijn geen douches en er is ook geen drinkwater. Elliot Key is het grootste eiland en de camping hier heeft iets meer faciliteiten. Er zijn toiletten, koude douches, picknick tafels en ook drink water is beschikbaar al wordt wel aangeraden om zelf extra mee te nemen. Je bent voor een nacht op de camping $25-$35 kwijt. Via de app van <a href=\"https://www.recreation.gov/mobile-app\" target=\"_blank\" rel=\"noopener\">Recreation</a> kun je reserveren.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reisperiode Biscayne National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Biscayne National Park heeft een subtropisch klimaat waardoor je het hele jaar zonneschijn hebt. De winters zijn droog en mild, de zomer is vochtig met af en toe onweersbuien. Het orkaanseizoen loopt van 1 juni tot en met 30 november.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Kamperen in Biscayne National Park\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"Boca Chita Key\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"11508\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Ontdek Biscayne National Park\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]Biscayne National Park is eigenlijk alleen via het water te ontdekken. Je kunt <a href=\"https://www.nps.gov/bisc/planyourvisit/guidedtours.htm\" target=\"_blank\" rel=\"noopener\">guided tours</a> boeken om het park te verkennen in een boot. Deze tours vertrekken bij Dante Fascell Visitor Center.\u00a0 Ook per <a href=\"https://www.nps.gov/bisc/planyourvisit/canoeing-and-kayaking.htm\" target=\"_blank\" rel=\"noopener\">kajak of kano</a> Biscayne National Park ontdekken is een leuke activiteit. Daarnaast zijn er tal van locaties waar je goed kunt snorkelen en duiken. Een voorbeeld is de Maritime Heritage Trail die je langs prachtige plekken leidt.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]24/7 en 365 dagen geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: lente[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]Gratis[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Kajakken op de wateren van Biscayne National Park\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"E\u00e9n van de beste manieren op het gebied te verkennen\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"11509\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Meer nationale parken\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:4738,4714,4689,4792\"][/vc_column][/vc_row]","post_title":"Biscayne National Park","post_link":"https://www.heyusa.com/nl/biscayne-national-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Biscayne National Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/04/mangrove-biscayne-np-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Biscayne National Park","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%inline_featured_image%":"0","%_edit_lock%":"1649158160:2","%_edit_last%":"1","%_thumbnail_id%":"11510","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"nationaal park florida\"]","%_yoast_wpseo_focuskw%":"Biscayne National Park","%_yoast_wpseo_metadesc%":"In Florida vind je naast de Everglades nog meer nationale parken. Een daarvan is Biscayne National Park. Tips voor Biscayne National Park.","%_yoast_wpseo_linkdex%":"77","%_wpgmp_location_address%":"Florida, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.4824229","%_wpgmp_metabox_longitude%":"-80.20831030000001","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_primary_category%":"169","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1677015095","taxonomy=category":"Biscayne National Park","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png"},"id":11503,"infowindow_disable":false},{"source":"post","title":"Art Deco Museum Miami","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Art Deco Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/04/art-deco-museum-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Art Deco Museum Miami</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1001 Ocean Dr, Miami Beach, FL 33139, Verenigde Staten","location":{"lat":"25.780258","city":"Miami Beach","state":"Florida","country":"Verenigde Staten","lng":"-80.1305038","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/art-deco-museum-miami/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Art Deco Museum\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:35px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:40px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]<strong>De wijk South Beach in Miami staat bekend om de vele Art Deco gebouwen die er nog staat. Gebouwd in 1920 en 1930, versieren de kleurrijke en opvallende gebouwen de straten van de wijk. Er staan honderden gebouwen die een beschermde status hebben. In het Art Deco Museum, dat zich bevindt in het Art Deco Welcome Center, kom je meer te weten over deze architectuur door middel van speciale tentoonstellingen, evenementen en workshops.</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"1001 Ocean Drive Miami Beach\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fmdpl.org%2Fwelcome-center%2Fart-deco-museum%2F|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Art Deco gebouwen in Miami\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Voor een goed overzicht van de Art Deco wijk van Miami kan een bezoek aan het Art Deco Museum niet ontbreken. South Beach in Miami heeft de grootste collectie Art Deco gebouwen ter wereld. Ze zijn gebouwd tussen 1920 en 1930 nadat de stad onder andere getroffen werd door een grote orkaan in 1925. In de jaren '70 was er sprake van dat de gebouwen vernietigd zouden worden, het Miami Design Preservation League voorkwam dat. Daardoor kunnen we nog steeds genieten van deze prachtige gebouwen in South Beach.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Art Deco Museum\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ontdek alles over de Art Deco stijl\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"11684\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Wat mag je niet missen in het Art Deco Museum\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Art Deco tentoonstelling\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: left;\">Kom meer te weten over de term Art Deco, het ontstaan en de invloeden van deze stijl. Je kunt de Art Deco stijl herkenen aan algemene symmetrie, getrapte daklijnen, glasblok, ronde poorten, terrazzovloeren en pastelkleuren. Voor hotels in South Beach werd vaak Neon verlichting gebruikt. Na een bezoek aan de Art Deco tentoonstelling kun je zelf op pad om de gebouwen in South Beach te ontdekken.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Mediterrranean Revival\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: left;\">Een andere stijl waar je meer te weten over kunt komen is de Mediterranean Revival. Diverse gebouwen in Miami zijn in deze stijl gebouwd. Nadat je meer te weten bent gekomen over deze specifieke bouwstijl, is Espa\u00f1ola Way en goede plek om de gebouwen te bekijken. Zoek naar klokkentorens, bogen, luifels, veranda's en balkons. Een bekend voorbeeld is Villa Casa Casuarina, het oude huis van legende <a href=\"https://www.heyusa.com/nl/moord-gianni-versace/\">Gianni Versace</a>.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][thb_postbackground source=\"post_type:post|by_id:-15153,9817\"][fullwidth_row content_width=\"100%\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ook leuk in Miami\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][fullwidth_row][thb_postgrid columns=\"4\" source=\"size:4|post_type:post|categories:168\"][/vc_column][/vc_row]","post_title":"Art Deco Museum Miami","post_link":"https://www.heyusa.com/nl/art-deco-museum-miami/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Art Deco Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/04/art-deco-museum-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Miami","post_tags":"Nevada","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1685102212:2","%_edit_last%":"2","%_wpb_vc_js_status%":"true","%post-primary-category%":"168","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Museum of Ice Cream in New York\"]","%_yoast_wpseo_focuskw%":"Art Deco Museum","%_yoast_wpseo_metadesc%":"Kom meer te weten over de Art Deco stroming in het Art Deco Museum in Miami. Tips voor het Art Deco Museum in Miami.","%_yoast_wpseo_linkdex%":"77","%_wpgmp_location_address%":"1001 Ocean Dr, Miami Beach, FL 33139, Verenigde Staten","%_wpgmp_location_city%":"Miami Beach","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.780258","%_wpgmp_metabox_longitude%":"-80.1305038","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_thumbnail_id%":"11683","%post_via%":"","%_yoast_wpseo_primary_category%":"168","%_yoast_indexnow_last_ping%":"1685102234","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Bezienswaardigheden Miami","taxonomy=post_tag":"Nevada","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":11682,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"South Beach Miami","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"South Beach\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/04/South-Beach-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">South Beach Miami</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"South Beach, Miami Beach, Florida 33139, Verenigde Staten","location":{"lat":"25.7826123","city":"Miami Beach","state":"Florida","country":"Verenigde Staten","lng":"-80.1340772","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/miami/south-beach-miami/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][vc_column_inner width=\"1/2\"][heyusa_heading tag=\"div\" heading=\"Welkom in South Beach!\" font_color=\"#282828\" font_size=\"40\" line_height=\"40\"][ultimate_heading main_heading=\"Wat te doen in South Beach?\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:35px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_column_text]<strong>De trendy wijk van Miami: South Beach. De wijk waar je dag en nacht terecht kunt voor vermaak. Daardoor ook een van de toeristische wijken van de stad. In South Beach vind je de beste restaurants en de leuke nachtclubs, maar kun je ook genieten van het strand, Art Deco architectuur en leuke activiteiten die je kunt ondernemen. Ontdek South Beach in Miami!</strong>[/vc_column_text][thb_iconbox type=\"left type1\" animation=\"\" icon_image=\"19383\" heading=\"Zon, zee &amp; strand\" description=\"South Beach\" icon_image_width=\"64\" description_font_size=\"15px\"][thb_iconbox type=\"left type1\" animation=\"\" icon_image=\"19378\" heading=\"Art Deco hotels\" description=\"Miami Beach\" icon_image_width=\"64\" description_font_size=\"15px\"][thb_iconbox type=\"left type1\" animation=\"\" icon_image=\"19386\" heading=\"Fotograferen\" description=\"Strandwacht huisjes\" icon_image_width=\"64\" description_font_size=\"15px\"][thb_iconbox type=\"left type1\" animation=\"\" icon_image=\"19379\" heading=\"Musea\" description=\"Art Deco Museum\" icon_image_width=\"64\" description_font_size=\"15px\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1640066907439{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"300px\"][vc_custom_heading text=\"Miami Beach\" font_container=\"tag:div|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Populairste strand van Miami\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"300px\"][parallax_row opacity=\"90\" enable_mobile=\"parallax-enable-mobile\" image=\"11671\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Het trendy Miami: South Beach\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">South Beach is de plek voor hippe en trendy plekken. Een wijk waar velen op af komen van toeristen, jongeren, rijken tot beroemdheden. Iedereen heeft wel een reden om naar South Beach te reizen. In South Beach vind je huizen in Art Deco architectuur, een van de beroemdste stranden van Miami en tal van uitgaansgelegenheden.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][vc_custom_heading text=\"Wat te doen in South Beach\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_row_inner css=\".vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"11708\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Lincoln Road\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een van de beste plekken in South Beach om the shoppen is op Lincoln Road. Tal van winkels, restaurants en uitgaansgelegenheden vind je op deze straat. Op Lincoln Road vind je nog enkele gebouwen uit het Art Deco tijdperk, waaronder het Lincoln Theatre. Naast de bekende winkelketens zijn er ook unieke boetieks, kunstgalerijen en trendy winkels op Lincoln Road. Ga een dagje shoppen en sluit af bij een van de vele restaurants op Lincoln Road.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"South Beach | Lincoln Road\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"11709\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"South Pointe Park\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Aan de zuidpunt van Miami Beach vind je een prachtige groene ruimte, het South Point Park. Je hebt vanaf hier een panoramisch uitzicht op de kustlijn van South Beach, de cruiseschepen die voorbij komen, de skyline van Downtown Miami en Fisher Island. Vanaf het park kun je direct het strand op wandelen. In het park zelf vind je mogelijkheden tot wandelen, picknicken, barbecue\u00ebn en een mini speeltuin. De zuidelijke pier in het park is 450 meter lang en een populaire plek om te vissen of te kijken naar kajakkers, surfers en jetski\u00ebrs.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"South Beach | 1 Washington Avenue\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"11707\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Espanola Way\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Espanola Way is niet alleen een belangrijke plek om te shoppen in Miami, je krijgt ook het idee dat je terug de tijd in bent gegaan en door een historisch Spaans dorp loopt. Espanola Way is schilderachtig en pittoresk, de vele gebouwen zijn ontworpen in Mediterrane Revival stijl. Naast leuke winkels en diverse kunstgalerijen kun je hier ook terecht voor de Spaanse keuken onder het genot van heerlijke cocktails.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"South Beach | Espanola Way\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"175px\"][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][heyusa_heading tag=\"div\" heading=\"Een dagje zon, zee &amp; strand\" font_size=\"55\" line_height=\"60\" font_color=\"#ffffff\"][ultimate_heading main_heading=\"Heerlijk genieten van een dagje strand is absoluut geen schande in Miami Beach!\" heading_tag=\"h3\" main_heading_color=\"#ffffff\" sub_heading_color=\"#ffffff\" alignment=\"left\" main_heading_font_size=\"desktop:30px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:300;\" sub_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" sub_heading_style=\"font-weight:300;\" sub_heading_font_size=\"desktop:25px;\" sub_heading_line_height=\"desktop:28px;\"]Pluk de dag! Neem je badlaken, zonnebrand, drinken en wat snacks mee voor een paar uurtjes op het beroemde strand van South Beach. Hier kun je zonnen, mensen kijken en even helemaal tot zen komen. Want het is immers vakantie![/ultimate_heading][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][parallax_row image=\"11651\"][vc_empty_space height=\"175px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" thb_row_padding=\"true\" thb_column_padding=\"true\" content_placement=\"middle\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][thb_image retina=\"retina_size\" full_width=\"true\" image=\"11613\"][/thb_image][/vc_column][vc_column width=\"1/2\"][vc_row_inner][vc_column_inner width=\"5/6\"][heyusa_heading tag=\"div\" heading=\"Memorial voor de Holocaust slachtoffers\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][vc_custom_heading text=\"Holocaust Memorial\" font_container=\"tag:h3|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: left;\">Het Holocaust Memorial werd bedacht door een groep Holocaust overlevenden van het Holocaust Memorial Committee. Het memorial is een herinnering aan de 6 miljoen Joden die tijdens het Nazi regime omkwamen tussen 1933 en 1945. Je vindt het memorial op Meridian Beach.</p>\r\n[/vc_column_text][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fholocaust-memorial-miami%2F|title:Holocaust%20Memorial\" btn_size=\"ubtn-small\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:25px;\" btn_line_height=\"desktop:30px;\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" thb_row_padding=\"true\" thb_column_padding=\"true\" content_placement=\"middle\"][vc_column width=\"1/2\"][vc_row_inner][vc_column_inner width=\"5/6\"][heyusa_heading tag=\"div\" heading=\"Art deco geschiedenis\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][vc_custom_heading text=\"Art Deco Museum\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: left;\">In South Beach vind je vele Art Deco gebouwen. Gebouwd tussen 1920 en 1930, versieren de kleurrijke en opvallende gebouwen de straten van de wijk. Er staan honderden gebouwen in Miami die een beschermde status hebben. In het <a href=\"https://www.heyusa.com/nl/art-deco-museum-miami/\">Art Deco Museum</a> kom je meer te weten over deze architectuur door middel van tentoonstellingen, evenementen en workshops.</p>\r\n[/vc_column_text][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fart-deco-museum-miami%2F|title:Art%20Deco%20Museum\" btn_size=\"ubtn-small\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:25px;\" btn_line_height=\"desktop:30px;\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][thb_image retina=\"retina_size\" full_width=\"true\" image=\"11683\"][/thb_image][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"75px\"][thb_blockgrid style=\"style8\" source=\"size:3|post_type:post|by_id:-12801,-12668,-11915,-11899,-11859,11604,11595,11582,-903\"][fullwidth_row content_width=\"100%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][thb_postbackground source=\"post_type:post|by_id:-9817,15153\"][fullwidth_row content_width=\"100%\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"De iconische strandwachters huisjes\" font_size=\"40\" line_height=\"40\" font_color=\"#b34a4c\"][ultimate_heading main_heading=\"South Beach op Miami Beach\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:40px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:45px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">De beroemde strandwachthuisjes in South Beach zijn iconisch aan de kustlijn van Miami Beach. Met hun opvallende kleuren en Art Deco-stijl voegen ze charme en karakter toe aan het strand. Deze historische huisjes zijn niet alleen functioneel, maar \u00f3\u00f3k een populaire attractie en een hotspot voor leuke foto's!</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_gallery gallery_type=\"thb-portfolio\" thb_columns=\"small-6 large-4\" images=\"19359,19360,19361,19362,19363,19364,10144,8726\" img_size=\"large\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"35px\"][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ontdek andere leuke wijken in Miami!\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][ultimate_heading main_heading=\"Bezoek andere leuke wijken in Miami\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:40px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:45px;\"][/ultimate_heading][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"25px\"][thb_postbackground style=\"style2\" source=\"by_id:-1262,-2267,-883,-850,-572,-557,-545,-456,12063,12074,11771,12101\"][/vc_column][/vc_row]","post_title":"South Beach Miami","post_link":"https://www.heyusa.com/nl/miami/south-beach-miami/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"South Beach\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/04/South-Beach-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Miami","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1640066907439{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1582997928099{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1710428777:1","%_edit_last%":"1","%_hide_featured%":null,"%_wpgmp_location_address%":"South Beach, Miami Beach, Florida 33139, Verenigde Staten","%_wpgmp_location_city%":"Miami Beach","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.7826123","%_wpgmp_metabox_longitude%":"-80.1340772","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"South Beach\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"9","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%inline_featured_image%":"0","%_yoast_wpseo_primary_category%":"167","%_thumbnail_id%":"11672","%standard-featured-credit%":"","%_yoast_wpseo_focuskw%":"South Beach Miami","%_yoast_wpseo_metadesc%":"Wat te doen in South Beach Miami? Tips voor bezienswaardigheden in South Beach Miami om niet te missen tijdens je bezoek!","%_yoast_wpseo_linkdex%":"78","%thb-reactions-votes%":"1","%_yoast_indexnow_last_ping%":"1710428605","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","taxonomy=category":"Miami","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""}},"id":11669,"infowindow_disable":false},{"source":"post","title":"Holocaust Memorial Miami","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Holocaust Memorial\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/04/holocaust-memorial-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Holocaust Memorial Miami</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1933-1945 Meridian Ave, Miami Beach, FL 33139, Verenigde Staten","location":{"lat":"25.7954768","city":"Miami Beach","state":"Florida","country":"Verenigde Staten","lng":"-80.1362109","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/holocaust-memorial-miami/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"25px\"][vc_custom_heading text=\"Holocaust Memorial Miami\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Op Meridian Beach vind je een monument ter nagedachtenis aan de Holocaust. Het Holocaust Memorial werd bedacht door een groep Holocaust overlevenden van het Holocaust Memorial Committee. Het memorial is een permanente reminder aan de 6 miljoen Joden die tijdens het Nazi regime omkwamen tussen 1933 en 1945.\r\n</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Gratis[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]9.30 uur tot zonsondergang[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612950540814{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Achtergrond Holocaust Memorial\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">Het Holocaust Memorial, ontworpen door Kenneth Treitser, bevat een reeks ruimtes die benadrukt worden door verschillende bronzen beeldhouwwerken. Zo is er een hand met een getatoe\u00eberd nummer te zien omringd door figuren die slachtoffer zijn van de oorlog. Het monument staat op de plek waar vroeger het huis van Holocaust overlevenden Williams en Florie Loeb en hun zoon Robert woonden. Zij immigreerden na de bezetting door de nazi's in Rotterdam naar Miami. Hun huis werd in de jaren '70 gesloopt om plaats te maken voor een parkeerplaats. Achter het <a href=\"https://holocaustmemorialmiamibeach.org/\" target=\"_blank\" rel=\"noopener\">Holocaust Memorial</a> staan nog de bomen die door de oorspronkelijke eigenaren in 1920 en 1930 geplant zijn.\u00a0</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Meer foto's van het Holocaust Memorial\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\" margin_design_tab_text=\"\"][/ultimate_heading][thb_image_slider images=\"11614,11613,11612,11611\"][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Miami\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"size:4|post_type:post|categories:168\"][/vc_column][/vc_row]","post_title":"Holocaust Memorial Miami","post_link":"https://www.heyusa.com/nl/holocaust-memorial-miami/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Holocaust Memorial\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/04/holocaust-memorial-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Miami","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1612950540814{background-color: #ededed !important;}","%_edit_last%":"1","%_edit_lock%":"1684841021:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"168","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"11612","%_yoast_wpseo_focuskw%":"Holocaust Memorial Miami","%_yoast_wpseo_title%":"%%title%% in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Bezoek het Holocaust Memorial Miami in South Beach Miami. Bekijk het prachtig memorial ter nagedachtenis aan de Tweede Wereldoorlog.","%_yoast_wpseo_linkdex%":"68","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Holocaust Memorial\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"1933-1945 Meridian Ave, Miami Beach, FL 33139, Verenigde Staten","%_wpgmp_location_city%":"Miami Beach","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.7954768","%_wpgmp_metabox_longitude%":"-80.1362109","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"168","%_yoast_indexnow_last_ping%":"1677015100","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Bezienswaardigheden Miami","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":11610,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"South Beach Segwaytour","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Segway South Beach\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/04/segway-south-beach-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">South Beach Segwaytour</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"952 Collins Ave, Miami Beach, FL 33139, Verenigde Staten","location":{"lat":"25.7803447","city":"Miami Beach","state":"Florida","country":"Verenigde Staten","lng":"-80.13206339999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/south-beach-segwaytour/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"South Beach Segwaytour\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_column_text]Stap op een Segway om de wijk South Beach in Miami te verkennen. Bekijk het prachtige Art Deco District, de mooiste staten van South Beach en rijdt langs bekende plekken in de wijk zoals Versace's Mansion, Lummus Park en South Pointe Pier Park. Kom meer te weten over de Holocaust wanneer de tour langs het Holocaust Memorial rijdt. Geniet van het zonnetje terwijl de Segway je langs de mooiste plekken van South Beach brengt terwijl je ondertussen van alles ontdekt over de cultuur, geschiedenis en inwoners van Miami. Met deze South Beach Segwaytour ontdek je South Beach op een leuke manier![/vc_column_text][vc_custom_heading text=\"Handige informatie voor de South Beach Segwaytour\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<b>Duur:</b><span style=\"font-weight: 400;\"> 30 minuten - 2 uur</span><span style=\"font-weight: 400;\">\r\n</span><b>Prijs</b><span style=\"font-weight: 400;\">: Vanaf 35 euro</span><span style=\"font-weight: 400;\">\r\n</span><b>Vertreklocatie</b><span style=\"font-weight: 400;\">: 952 Collins Ave, Miami Beach</span><span style=\"font-weight: 400;\">\r\n</span><b>Openingstijden:</b> Dagelijks om 12.30 uur en 16.30 uur[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fmiami-l176%2Fsouth-beach-segway-tour-t392429%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dsegwaysouthbeach|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"20px\"][/vc_column][vc_column width=\"1/3\"][thb_image retina=\"retina_size\" box_shadow=\"medium-shadow\" thb_border_radius=\"10px\" image=\"11605\"][/thb_image][vc_empty_space height=\"20px\"][vc_column_text][/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Miami\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"size:4|post_type:post|categories:168\"][/vc_column][/vc_row]","post_title":"South Beach Segwaytour","post_link":"https://www.heyusa.com/nl/south-beach-segwaytour/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Segway South Beach\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/04/segway-south-beach-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Miami","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1685444065:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"168","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style3","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":{"2":{"title":"","post_source_url":""}},"%_yoast_wpseo_focuskw%":"South Beach Segwaytour","%_yoast_wpseo_metadesc%":"De wijk South Beach verkennen in Miami? Boek dan een Segwaytour door South Beach en kom lang bekende plekken en ontdek meer over de wijk.","%_yoast_wpseo_linkdex%":"61","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Segway Miami\"]","%_wpgmp_location_address%":"952 Collins Ave, Miami Beach, FL 33139, Verenigde Staten","%_wpgmp_location_city%":"Miami Beach","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.7803447","%_wpgmp_metabox_longitude%":"-80.13206339999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"11606","%inline_featured_image%":"0","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"168","%_yoast_indexnow_last_ping%":"1685444173","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Bezienswaardigheden Miami","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":11604,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"South Beach fietstour","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"South Beach fietstour\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/04/fietspad-south-beach-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">South Beach fietstour</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1401 Washington Ave, Miami Beach, FL 33139, Verenigde Staten","location":{"lat":"25.785522","city":"Miami Beach","state":"Florida","country":"Verenigde Staten","lng":"-80.13174049999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/fietstour-south-beach/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"South Beach fietstour\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_column_text]Ontdek de mooiste plekken in South Beach tijdens een <a href=\"https://www.getyourguide.com/miami-l176/miami-south-beach-bike-tour-t94953/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=southbeachfietstour\" target=\"_blank\" rel=\"noopener\">twee uur durende fietstour</a>. Leer meer over de geschiedenis van de wijk, de cultuur en hoor boeiende verhalen van de gids over vreemde eigenaardigheden in de buurt. Een leuke en interessante tour voor mensen die op een actieve manier kennis willen maken met South Beach.[/vc_column_text][vc_column_text]South Beach is de trendy wijk van Miami. Een wijk waar je dag en nacht naar toe kunt voor vermaak. Daardoor is het ook een van de toeristische wijken van Miami. In South Beach vind je de beste restaurants en de leuke nachtclubs, maar kun je ook genieten van het strand en art deco architectuur. Met een fietstour ontdek je al deze leuke plekken in <a href=\"https://www.heyusa.com/nl/miami/south-beach-miami/\">South Beach</a>![/vc_column_text][vc_custom_heading text=\"Handige informatie voor de fietstour door South Beach\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<b>Duur:</b><span style=\"font-weight: 400;\"> 1,5 - 2 uur</span><span style=\"font-weight: 400;\">\r\n</span><b>Prijs</b><span style=\"font-weight: 400;\">: Vanaf 48 euro</span><span style=\"font-weight: 400;\">\r\n</span><b>Vertreklocatie</b><span style=\"font-weight: 400;\">: 1401 Washington Ave. Miami Beach</span><span style=\"font-weight: 400;\">\r\n</span><b>Openingstijden:</b> Dagelijks om 11.00 uur[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fmiami-l176%2Fmiami-south-beach-bike-tour-t94953%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dsouthbeachfietstour|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"20px\"][/vc_column][vc_column width=\"1/3\"][thb_image retina=\"retina_size\" box_shadow=\"medium-shadow\" thb_border_radius=\"10px\" image=\"11598\"][/thb_image][vc_empty_space height=\"20px\"][vc_column_text][/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Miami\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"size:4|post_type:post|categories:168\"][/vc_column][/vc_row]","post_title":"South Beach fietstour","post_link":"https://www.heyusa.com/nl/fietstour-south-beach/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"South Beach fietstour\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/04/fietspad-south-beach-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Miami","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1685444562:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"168","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style3","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":{"2":{"title":"","post_source_url":""}},"%_yoast_wpseo_focuskw%":"South Beach fietstour","%_yoast_wpseo_metadesc%":"De wijk South Beach verkennen in Miami? Boek dan een fietstour door South Beach en kom lang bekende plekken en ontdek meer over de wijk.","%_yoast_wpseo_linkdex%":"72","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Fietsen Miami\"]","%_wpgmp_location_address%":"1401 Washington Ave, Miami Beach, FL 33139, Verenigde Staten","%_wpgmp_location_city%":"Miami Beach","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.785522","%_wpgmp_metabox_longitude%":"-80.13174049999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"11599","%inline_featured_image%":"0","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"168","%_yoast_indexnow_last_ping%":"1685444654","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Bezienswaardigheden Miami","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":11595,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Art Deco District Miami","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"bezienswaardigheden miami\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/09/art-deco-district-miami-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Art Deco District Miami</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1001 Ocean Dr, Miami Beach, FL 33139, Verenigde Staten","location":{"lat":"25.7803215","city":"Miami Beach","state":"Florida","country":"Verenigde Staten","lng":"-80.1303928","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/art-deco-district-miami/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"25px\"][vc_custom_heading text=\"Art Deco District in Miami\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Een leuke bezienswaardigheid in South Beach Miami is het beroemde Art Deco District. Niet alleen de plek om huizen in art deco stijl te bekijken, ook in de avonden een gezellige plek voor een drankje. Ontdek waar je precies moet zijn om de mooiste art deco huizen in Miami te bekijken.\r\n</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Gratis[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612950540814{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Wat is het Art Deco District in Miami?\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">In het Art Deco District in Miami vind je ruim 800 historische gebouwen die voldoen aan de Art Deco stroming. In 1920 en 1930 werden vele huizen gebouwd volgens de kenmerken van deze stroming. Ze zien er vaak futuristisch uit, hebben pastelkleuren en bij de <a href=\"https://www.booking.com/searchresults.en.html?district=994&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=artdecosouthbeach\" target=\"_blank\" rel=\"noopener\">hotels</a> is vaak neonverlichting aanwezig. Je vindt het Art Deco District in de wijk South Beach aan Miami Beach, 5th Street &amp; 3rd Street. De straten waar je veel Art Deco gebouwen treft zijn: Ocean Drive, Collins Avenue en Washington Avenue.</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Art Deco stijl\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Herkenbare kleuren en lijnen\" font_size=\"40\" line_height=\"40\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"11584\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Art Deco tours\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Een leuke manier om meer te weten te komen over het <span style=\"text-decoration: underline;\"><a href=\"https://www.getyourguide.com/miami-l176/miami-south-beach-art-deco-private-walking-tour-in-french-t408306/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=artdecodistricttekst\" target=\"_blank\" rel=\"noopener\">Art Deco District</a></span> is door aan te sluiten bij een tour. Er worden dagelijks wandeltochten aangeboden in de buurt. Je komt langs vele historische gebouwen en leert meer over de specifieke kenmerken van de stroming.\r\n</span>[/vc_column_text][ult_buttons btn_title=\"Boek hier je tickets voor een Art Deco wandeltour\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fmiami-l176%2Fmiami-south-beach-art-deco-private-walking-tour-in-french-t408306%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dartdecodistrictbanner|title:Art%20Deco%20District|target:_blank\" btn_align=\"ubtn-center\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Zelf Art Deco huizen bekijken\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Je kunt de Art Deco gebouwen makkelijk zelf herkennen wanneer je door de wijk loopt. De lijnen van de gebouwen, de kleuren, de rondingen en de fonteinen vallen op wanneer je door het district wandelt. Wandel door Lummus Park om Art Deco huizen te bekijken of langs vele hotels met de specifieke neon-verlichting of bekijk het Clevelander South Beach. Wil je meer weten over art deco? Bezoek dan het <a href=\"https://www.heyusa.com/nl/art-deco-museum-miami/\">Art Deco Museum</a>.\u00a0</span>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Enjoy your evening!\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_custom_heading text=\"Neem een drankje bij een van de caf\u00e9s op Ocean Drive\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:3\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"11585\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Miami\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"size:4|post_type:post|categories:-168|by_id:15153,11682,9734,14375\"][/vc_column][/vc_row]","post_title":"Art Deco District Miami","post_link":"https://www.heyusa.com/nl/art-deco-district-miami/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"bezienswaardigheden miami\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/09/art-deco-district-miami-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Miami","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1612950540814{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"2","%_edit_lock%":"1684840776:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"168","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"8766","%_yoast_wpseo_focuskw%":"Art Deco District","%_yoast_wpseo_title%":"%%title%% in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Bezoek het Art Deco District in South Beach Miami. Bekijk de prachtige huizen aan Miami Beach in Art Deco stijl.","%_yoast_wpseo_linkdex%":"78","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"1001 Ocean Dr, Miami Beach, FL 33139, Verenigde Staten","%_wpgmp_location_city%":"Miami Beach","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.7803215","%_wpgmp_metabox_longitude%":"-80.1303928","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"168","%_yoast_indexnow_last_ping%":"1684840813","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Bezienswaardigheden Miami","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":11582,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Neon Museum in Las Vegas","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Las Vegas\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/02/Neon-Museum-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Neon Museum in Las Vegas</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"770 Las Vegas Blvd N, Las Vegas, NV 89101, Verenigde Staten","location":{"lat":"36.1769882","city":"Las Vegas","state":"Nevada","country":"Verenigde Staten","lng":"-115.1353374","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/neon-museum-las-vegas/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text]<strong>Een stukje geschiedenis, maar vooral ook een hele fotogenieke plek is het Neon Museum in Las Vegas. Op het kerkhof van neon signs wordt een verhaal verteld over de geschiedenis van Las Vegas. Elk van de neon signs in de collectie van het museum vertelt het verhaal van een bepaalde periode van de stad.\u00a0</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"770 Las Vegas Blvd\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.neonmuseum.org%2F|title:Bestel%20je%20tickets\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Museum met een stukje geschiedenis van Las Vegas\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Het begon allemaal met het verlies van het iconische bord uit The Sands. Het enorme bord werd vervangen en er was geen plaats om de oude te stallen. Het Allied Arts Council en de stad Las Vegas sloegen de armen in \u00e9\u00e9n en begonnen deze 'overtollige' borden een plek te geven. De offici\u00eble opening van het <a href=\"https://www.neonmuseum.org/\" target=\"_blank\" rel=\"noopener\">Neon Museum</a> was in november 1996. Het was destijds alleen toegankelijk op afspraak. In 2005 kreeg het museum een lobby, het historische La Concha Motel schonk hun lobby aan het museum. De plannen om een museum te openen werden steeds concreter en na een aantal subsidies en donaties werd het museum voor iedereen toegankelijk op 27 oktober 2012. Inmiddels staan er meer dan 24 gerestaureerde verlichte borden en 250 andere signs in het museum.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Neon Museum\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\" margin_design_tab_text=\"\"][/ultimate_heading][ultimate_heading main_heading=\"Ontdek een stukje geschiedenis van Las Vegas\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"6104\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"in het Neon Museum\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:300;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Boneyard Park\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Het Boneyard Park werd in 2012 opgericht met de letters NEON gespeld in de vorm van de borden van het Golden Nugget (N), Caesars Palace (E), Bionion's Horseshoe (O) en Desert Herberg (N). Je vindt in dit deel van het museum signs die gebruikt werden voor bijvoorbeeld Stardust, Riviera, Desert Inn en Caesars Palace. Ook kleinere signs zijn hier onder gebracht, net als bijvoorbeeld een sculptuur van een gigantische schedel van het Treasure Island Hotel en Casino.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"North Gallery\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In 2018 werd begonnen met een kunstinstallatie van 30 minuten genaamd Briljant! De ontwerper van deze installatie is Craig Winslow die hiervoor gebruik maakte van overbodige borden in combinatie met hedendaagse muziek. Hier kun je ook terecht voor speciale evenementen en fotoshoots.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Stardust\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\" margin_design_tab_text=\"\"][/ultimate_heading][ultimate_heading main_heading=\"Icoon in Las Vegas\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"11543\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ook leuk in Las Vegas\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_empty_space height=\"50px\"][fullwidth_row][thb_postgrid columns=\"4\" source=\"size:4|post_type:post|categories:54\"][/vc_column][/vc_row]","post_title":"Neon Museum in Las Vegas","post_link":"https://www.heyusa.com/nl/neon-museum-las-vegas/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Las Vegas\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/02/Neon-Museum-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Las Vegas","post_tags":"Nevada","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1667477158:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"54","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Museum of Ice Cream in New York\"]","%_yoast_wpseo_focuskw%":"Neon Museum","%_yoast_wpseo_metadesc%":"In het Neon Museum vind je een stukje geschiedenis van Las Vegas. Tips voor een bezoek aan het Neon Museum Las Vegas.","%_yoast_wpseo_linkdex%":"73","%_wpgmp_location_address%":"770 Las Vegas Blvd N, Las Vegas, NV 89101, Verenigde Staten","%_wpgmp_location_city%":"Las Vegas","%_wpgmp_location_state%":"Nevada","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"36.1769882","%_wpgmp_metabox_longitude%":"-115.1353374","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_thumbnail_id%":"3733","%post_via%":"","%_yoast_wpseo_primary_category%":"54","%_yoast_indexnow_last_ping%":"1677015108","taxonomy=category":"Bezienswaardigheden Las Vegas","taxonomy=post_tag":"Nevada","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":11542,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Everglades- en alligatoravontuur bij Gator Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Gator Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/03/gator-park-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Everglades- en alligatoravontuur bij Gator Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"24050 SW 8th St, Miami, FL 33194, Verenigde Staten","location":{"lat":"25.760632","city":"Miami","state":"Florida","country":"Verenigde Staten","lng":"-80.581148","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/everglades-alligator-avontuur/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Spot Alligators bij het Gator Park in de Everglades\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Ontdek het Everglades National Park en ga op zoek naar alligators, schildpadden of zeldzame panter in Florida. Vaar mee op een moerasboot die uitermate geschikt is voor het moerasland van de River of Grass, de eindeloze prairies van zaaggras die tot drie meter boven het wateroppervlak uitsteken. Maak je bezoek compleet door de dieren- en alligatorshow te bekijken die er dagelijks gehouden wordt.[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf $27,99 dollar per persoon[/ultimate_icon_list_item][/ultimate_icon_list][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Feverglades-city-l95255%2Feverglades-national-park-airboat-tour-and-wildlife-show-t172401%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dairboatgatorparkboven|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612946867021{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Alligators in de Everglades\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">Florida is de beste plek in Amerika om alligators te zien in het wild, het wordt niets voor niets alligator state genoemd. Er leven meer dan 1,5 miljoen alligators in de staat Florida. Ondanks dat de <a href=\"https://www.heyusa.com/nl/everglades-national-park/\">Everglades</a> het grootste nationale park is van de staat, leven daar maar 200.000 alligators. Desondanks een goede plek om de grootste reptiel van Noord Amerika te zien. Het zoete water van de Everglades is de perfecte thuisbasis voor de alligator die leeft van vogels, schildpadden en slangen. En of ze ook mensen eten? In principe niet, maar een alligator zal er alles aan doen om zichzelf en eventuele jongen te beschermen.\u00a0</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Gator Park\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Pak de airboat om alligators te spotten\" font_size=\"40\" line_height=\"40\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"11412\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Airboat tour\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">De manier om foto's te maken van dieren in hun natuurlijke habitat in de Everglades is per airboat. Gidsen zorgen ervoor dat je zowel grote als kleine alligators kunt zien. Ook schildpadden behoren tot de mogelijkheden om te fotograferen vanuit de airboat. Op snelheid vaar je door de wetlands van de Everglades. Op de eilanden die je tegenkomt heb je kans om wasberen, witstaartherten of wilde zwijnen te zien. De airboat tochten vertrekken iedere 20-30 minuten.\u00a0</span>[/vc_column_text][ultimate_heading main_heading=\"Vanaf $27,99\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_margin=\"margin-top:5px;margin-bottom:5px;\"][/ultimate_heading][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Feverglades-city-l95255%2Feverglades-national-park-airboat-tour-and-wildlife-show-t172401%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dairboatgatorpark|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Gator Park in de Everglades\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Hoewel de natuur altijd lastig te voorspellen is, heb je bij het Gator Park altijd de kans om alligators te zien. Bij hun beroemde alligatorshow krijg je niet alleen de alligators te zien, ook hun beroemde worstelshow komt voorbij. Een techniek die van oorsprong gebruikt werd door de Seminole Indianen om alligators te vangen.[/vc_column_text][ultimate_heading main_heading=\"Vanaf $27,99\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_margin=\"margin-top:5px;margin-bottom:5px;\"][/ultimate_heading][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Feverglades-city-l95255%2Feverglades-national-park-airboat-tour-and-wildlife-show-t172401%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dairboatgatorpark|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Gift Shop\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Bij het Gator Park bevindt zich een souvenir shop waardoor je thuis kunt komen met de perfecte souvenirs. Hang bijvoorbeeld een realistische replica van een alligatorkop aan je muur of neem het Gourmet Gator kookboek meer. Tal van souvenirs zijn er aanwezig, dus thuiskomen zonder leuk cadeautje kan niet meer.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Oog in oog met een alligator\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Durf jij het aan?\" font_size=\"40\" line_height=\"40\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"11413\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tickets voor Gator Park\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Verschillende mogelijkheden voor tickets\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Om Gator Park in de Everglades te bezoeken kun je verschillende <a href=\"https://www.getyourguide.com/everglades-city-l95255/everglades-national-park-airboat-tour-and-wildlife-show-t172401/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=airboatgatorpark\" target=\"_blank\" rel=\"noopener\">tickets</a> aanschaffen. De reguliere airboat ticket inclusief wildlife show heb je vanaf $27,99, je kunt ook kiezen voor een private tour ($425).\u00a0</span>[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Feverglades-city-l95255%2Feverglades-national-park-airboat-tour-and-wildlife-show-t172401%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dairboatgatorparkonderin|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie Gator Park\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>24050 SW 8 St. Miami FL 33194</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Dagelijks van 9.00-17.00 uur - laatste airboat 17.00, laatste wildlife show 16.30 uur</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<strong>Openingstijden kunnen afwijken tijdens Kerst en Oud en Nieuw</strong>[/ultimate_icon_list_item][/ultimate_icon_list][vc_custom_heading text=\"Wat is het beste moment om de Gator Park te bezoeken?\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In principe kun je het hele jaar alligators zien in de Everglades. Echter zijn de wintermaanden de periode waarin het lastiger is om alligators in het wilde te zien. De waterstand is dan laag en alligators zitten meer verstopt hierdoor. De lente en de zomer zijn de beste periode.[/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Foto's alligators in de Everglades\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][thb_image_slider images=\"10787,4734,9844,4732,11412,11413,11411\"][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Miami\" font_container=\"tag:div|font_size:50|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|categories:168\"][/vc_column][/vc_row]","post_title":"Everglades- en alligatoravontuur bij Gator Park","post_link":"https://www.heyusa.com/nl/everglades-alligator-avontuur/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Gator Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/03/gator-park-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Miami","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1612946867021{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"2","%_edit_lock%":"1684840020:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"11411","%_yoast_wpseo_focuskw%":"Gator Park in de Everglades","%_yoast_wpseo_title%":"Gator Park in de Everglades %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Gator Park in de Everglades is een van de must do attracties in het Everglades National Park. Stap in de boot om alligators te zien in de Everglades.","%_yoast_wpseo_linkdex%":"73","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"alligators florida\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"24050 SW 8th St, Miami, FL 33194, Verenigde Staten","%_wpgmp_location_city%":"Miami","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.760632","%_wpgmp_metabox_longitude%":"-80.581148","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"168","%_yoast_indexnow_last_ping%":"1684840009","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Bezienswaardigheden Miami","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":11400,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Museum of Ice Cream in New York","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Museum of Ice Cream\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/03/museum-of-ice-cream-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Museum of Ice Cream in New York</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"558 Broadway, New York, NY 10012, Verenigde Staten","location":{"lat":"40.7238545","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.99791669999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/museum-of-ice-cream-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text]<strong>Een museum over ijs zie je niet zo vaak voorbij komen. In een stad als New York kan het natuurlijk niet ontbreken: het Museum of Ice Cream (MOIC). Een experience die volledig in het teken staat van ijs. Een walhalla voor ijsliefhebbers want naast dat je alles te weten komt over ijs, kun je er natuurlijk ook ijs proeven!</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"558 Broadway\"][thb_iconlist icon=\"fas fa-subway\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Prince Street Station | R | W\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fnew-york-city-museum-of-ice-cream-general-admission-ticket-t382713%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dmuseumoficecreamnyc|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Het museum over ijs!\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Het Museum of Ice Cream is niet alleen de plek waar je alles te weten komt over ijs, het is ook erg Instagrammable ingericht waardoor je foto's blijft maken. Daardoor is het Museum of Ice Cream meer een experience dan een museum alleen. In dertien verschillende ruimtes ontdek je alles over ijs, kun je ijs proeven, zijn er activiteiten met ijs te doen en kun je toffe foto's maken. Doe voor je bezoek alvast wat inspiratie op op hun <a href=\"https://www.instagram.com/museumoficecream/\" target=\"_blank\" rel=\"noopener\">Instagram account</a> voordat je die kant op gaat.\u00a0 \"Rediscover the kid in you\" is het motto van het museum en dat gaat je zeker lukken!</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Museum of Ice Cream\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Dompel je onder in alle aspecten van ijs\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"11344\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"In het Museum of Ice Cream\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Experience\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In dertien verschillende ruimtes maak je kennis met alle aspecten van ijs. Je leert over ijs door middel van het proeven van ijs op een zwevende desserttafel, door te glijden van een glijbaan van 3 verdiepingen om ijs te verzamelen of door een duik te nemen in een zwembad gevuld met miljoenen hagelslag. Laat het kind weer in je bovenkomen in een speeltuin vol met allerlei ijsaspecten!</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Cafe &amp; Shop\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Natuurlijk hoort er bij een museum als dit een leuk cafe waar je allerlei soorten ijs kunt proeven. Proef verschillende soorten ijs in de MOIC smaken in kopjes, wafels, milkshakes, ijscoupes, cocktails en boozy shakes. Mocht je nu nog meer willen weten over ijs? Er worden regelmatig workshops en evenementen houden.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"IJs experience\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Rediscover the kid in you\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"11346\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ook leuk in New York City:\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][fullwidth_row][thb_postgrid columns=\"4\" source=\"post_type:post|by_id:1594,1312,408,1559\"][/vc_column][/vc_row]","post_title":"Museum of Ice Cream in New York","post_link":"https://www.heyusa.com/nl/museum-of-ice-cream-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Museum of Ice Cream\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/03/museum-of-ice-cream-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea New York","post_tags":"New York","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1680676469:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"16","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Museum of Ice Cream in New York\"]","%_yoast_wpseo_focuskw%":"Museum of Ice Cream","%_yoast_wpseo_metadesc%":"Een leuk en interactief museum in New York is het Museum of Ice Cream in New York. Een ervaring die in het teken staat van ijs!","%_yoast_wpseo_linkdex%":"74","%_wpgmp_location_address%":"558 Broadway, New York, NY 10012, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7238545","%_wpgmp_metabox_longitude%":"-73.99791669999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_thumbnail_id%":"11345","%post_via%":[{"title":"Foto's Museum of Ice Cream \u00a9 Nicole Franzen","post_source_url":""}],"%_yoast_indexnow_last_ping%":"1677015114","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Musea New York","taxonomy=post_tag":"New York","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":11341,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Little Island","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Little Island\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/03/little-island-aerial-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Little Island</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Pier 55 at Hudson River Park Hudson River Greenway, New York, NY 10014, Verenigde Staten","location":{"lat":"40.7420577","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-74.0101494","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/little-island/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"25px\"][vc_custom_heading text=\"Little Island in New York\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]New York is een opvallend park rijker. Na het toffe concept van The High Line is daar een zwevend park boven de Hudson Rivier. Verbonden met twee voetgangersbruggen aan Meatpacking District, is het een opvallend park te noemen. Je vindt op Little Island meerdere hoogteverschillen waardoor je ook nog eens een geweldig uitzicht hebt over New York. Maak kennis met Little Island in New York![/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Gratis[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-location-arrow\"]Pier 55 Hudson River Park[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612950540814{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Tips voor een bezoek aan Little Island\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Het eiland is gratis toegankelijk voor iedereen. Om de drukte te reguleren tijdens de drukke maanden, is het noodzakelijk om van te voren een tijdslot te <a href=\"https://littleisland.org/\" target=\"_blank\" rel=\"noopener\">reserveren</a>. Little Island is open van 6.00 uur tot 23.00 uur. Je vindt de twee ingangen aan de Hudson River Park Esplanade, hier heb je de south bridge en north bridge die toegang geven tot het park. Tussen mei en oktober zijn er mogelijkheden tot het kopen van eten en drinken.</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Little Island\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Een van de leukste parken in New York\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"11333\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Weetjes over Little Island\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Little Island in New York kwam tot stand dankzij miljonair Barry Diller en zijn vrouw Diane van Furstenberg. Zij deden een donatie van 260 miljoen dollar voor de bouw van het eiland na de beschadiging van orkaan Sandy in 2013. Hij koos er, samen met ontwerper Thomas Heatherwick, voor om een nieuwe openbare ruimte te cre\u00ebren waarin je natuur en kunst kunt ervaren. Heatherwick is trouwens ook de ontwerper van <a href=\"https://www.heyusa.com/nl/the-vessel-hudson-yards/\">The Vessel</a>. Het ontwerp is gebaseerd op een drijvend blad op water. De bouw van Little Island startte in 2017 en in 2021 werd het project afgerond.\r\n</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Wat kun je doen op Little Island\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Little Island op Pier 55 is een groene oase geworden. Een wandeling brengt je langs talrijke verschillende bomen, struiken en andere planten. Je vindt op het eiland drie verschillende uitkijkpunten vanwaar je de skyline van New York kunt bekijken. Op de grasvelden is het mogelijk om te relaxen in de zomermaanden. In de noordwestelijke hoek ligt het amfitheater waar regelmatig evenementen worden gehouden.\u00a0</span>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Enjoy the view!\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_custom_heading text=\"Uitzichten op de skyline van New York\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:3\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"11334\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:1571,968,910,1784\"][/vc_column][/vc_row]","post_title":"Little Island","post_link":"https://www.heyusa.com/nl/little-island/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Little Island\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/03/little-island-aerial-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Parken New York","post_tags":"New York","%_wpb_shortcodes_custom_css%":".vc_custom_1612950540814{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1716876455:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"14","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"11332","%_yoast_wpseo_focuskw%":"Little Island","%_yoast_wpseo_title%":"%%title%% in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een van de nieuwste parken in New York is Little Island. Benieuwd wat je er allemaal kunt doen? Lees meer over Little Island New York.","%_yoast_wpseo_linkdex%":"77","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Little Island New York\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"Pier 55 at Hudson River Park Hudson River Greenway, New York, NY 10014, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7420577","%_wpgmp_metabox_longitude%":"-74.0101494","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%post_via%":[{"title":"Foto's Little Island \u00a9 Michael Grimm","post_source_url":""}],"%_yoast_indexnow_last_ping%":"1677015117","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Parken New York","taxonomy=post_tag":"New York","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":11330,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Four Corners Monument","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Four Corners\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/03/four-corners-usa-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Four Corners Monument</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"597 NM-597, Teec Nos Pos, AZ 86514, Verenigde Staten","location":{"lat":"36.9990829","city":"Teec Nos Pos","state":"Arizona","country":"Verenigde Staten","lng":"-109.0452233","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/four-corners-monument/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"25px\"][vc_custom_heading text=\"Four Corners Monument\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\"><span style=\"color: #000000;\">In vier staten tegelijkertijd zijn? Onmogelijk, behalve op \u00e9\u00e9n plek in Amerika: Four Corners. Op dit unieke punt grenzen Arizona, Colorado, New Mexico en Utah aan elkaar. Hoewel het in de middle - of -nowhere ligt is Four Corners USA een bezienswaardigheid die vele mensen trekt.\u00a0</span></span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]$5[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612950540814{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Four Corners USA\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"color: #000000;\">Het <a style=\"color: #000000;\" title=\"Four Corners Monument\" href=\"http://www.utah.com/playgrounds/four_corners.htm\" target=\"_blank\" rel=\"noopener\"><span style=\"text-decoration: underline;\">Four Corners Monument </span></a>ligt in de middle of nowhere, omgeven door maanlandschap, met het kleine Teec Nos Pos (Arizona) als dichtstbijzijnde plaatsje op een kilometer of tien. In een straal van 50 kilometer zijn de aanwezigheid van benzinestations, winkels en restaurants zeer beperkt, dus ga goed bepakt op weg. Vanuit Arizona, Colorado of New Mexico dien je eerst de US Route 160 te nemen, rijd dan vervolgens New Mexico in en houd de State Route 597 aan. Deze loopt over in 4 Corners Road en brengt je richting het vierstatenpunt. Trek hier geen hele dag voor uit; een uurtje is meer dan zat om een goede indruk te krijgen en nog een souvenirtje aan te schaffen. Zie het als een moment om even uitgebreid de benen te strekken tijdens je tocht door het midwesten en tegelijkertijd een unieke plek te bezichtigen.</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"De samenkomst van 4 staten\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"In welke sta jij?\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"11034\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Geschiedenis Four Corners\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Het gebied Four Corners werd vanaf 1868 - Mexico had na de verloren oorlog een groot deel van New Mexico afgestaan aan Amerika - voor het eerst onder de loep genomen door opzichtigers en astronomen van de overheid. Ehud Darling, Chandler Robbins, Rollin Reeves en Howard Carpenter onderzochten de grenslijnen van de vier staten en markeerden het.</span>\r\n\r\nIn 1899 troffen onderzoekers Hubert Page en James Lentz een vernield monument aan, waarna ze een nieuwe steen op de originele Four Corners-locatie plaatsten. Everett Kimmell van General Land Office, destijds een overheidsinstantie dat zich ontfermde over beheer van federaal land, vernieuwde de gedenkplaat in 1931 met brons en beton als materialen. The Bureau of Land Management en The Bureau of Indian Affairs zorgden in 1962 voor bestrating rondom het bouwwerk van Kimmell.\r\n\r\nKadastrale onderzoekers\u00a0Darryl Wilson en Jack Eaves gingen in 1992 weer een stapje verder met het aanbrengen van een aluminium bronzen plaat. Het monument zoals vandaag de dag te zien, werd herbouwd door The Bureau of Land Management. De laatste grote ingreep dateert van 2010, toen er voor 680.000 dollar een renovatieproject plaatsvond. De steen werd daarbij (acht voet) verplaatst en het omliggende terrein werd opgeknapt.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"De Navajo\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Het gebied rondom Four Corners behoort tot een indianenreservaat; de Navajo is er nog in groten getale vertegenwoordigd en dat is te merken. Er is een kleine markt waar indianen sieraden, t-shirts en andere zaken verkopen. Verder staat er een plaquette met daarop in vogelvlucht de ontstaansgeschiedenis. Even buiten het centrale plein vind je bankjes waar je een broodje - mits zelf meegebracht - kunt eten en kunt genieten van de uitgestrekte, dorre vlaktes in de omgeving die veel weg hebben van een maanlandschap.\r\n</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"In de buurt van Four Corners\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\"><span style=\"color: #000000;\">Four Corners mag dan een erg afgelegen locatie zijn, toch ligt de plek niet heel erg ongunstig als je onderweg bent richting bijvoorbeeld de <a href=\"https://www.heyusa.com/nl/grand-canyon-national-park/\">Grand Canyon</a>, <a href=\"https://www.heyusa.com/nl/zion-national-park-utah/\">Zion</a> en <a href=\"https://www.heyusa.com/nl/navajo-tribal-park/monument-valley/\">Monument Valley</a> (ten westen) en in het oosten in Colorado tref je Mesa Verde National Park op niet heel grote afstand. Maar voor je je weg vervolgt naar \u00e9\u00e9n van deze toeristische trekpleisters: vergeet niet nog even je lenigheid te testen op het kruispunt.</span></span>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Four Corners\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_custom_heading text=\"In the middle-of-nowhere\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:3\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"11032\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te bezoeken\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:12842,2661,4638,4574\"][/vc_column][/vc_row]","post_title":"Four Corners Monument","post_link":"https://www.heyusa.com/nl/four-corners-monument/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Four Corners\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/03/four-corners-usa-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1612950540814{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1665738010:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"65","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"11031","%_yoast_wpseo_focuskw%":"Four Corners","%_yoast_wpseo_metadesc%":"Four Corners Monument is de plek waar vier verschillende staten bij Teec Nos Pos waar Arizona, Colorado, New Mexico en Utah samenkomen.","%_yoast_wpseo_linkdex%":"82","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Four Corners Monument\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"597 NM-597, Teec Nos Pos, AZ 86514, Verenigde Staten","%_wpgmp_location_city%":"Teec Nos Pos","%_wpgmp_location_state%":"Arizona","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"36.9990829","%_wpgmp_metabox_longitude%":"-109.0452233","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"65","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015116","taxonomy=category":"Bezienswaardigheden","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":11027,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Everglades Alligator Farm","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Everglades NP\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/03/Everglades3-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Everglades Alligator Farm</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"40351 SW 192nd Ave, Homestead, FL 33034, Verenigde Staten","location":{"lat":"25.393168","city":"Homestead","state":"Florida","country":"Verenigde Staten","lng":"-80.5012007","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/everglades-alligator-farm/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Spot Alligators in bij de Everglades Alligator Farm\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een bezoek aan de Everglades kan eigenlijk niet ontbreken wanneer je in Florida of Miami bent. Het is een prachtig natuurgebied met veel wilde dieren. Het grootste reptiel van Noord Amerika vind je onder andere in de Everglades. De leukste manier om kennis te maken met dit reptiel is het bezoeken van de Everglades Alligator Farm. Je kunt hier met een airboat door de Everglades op zoek naar alligators in het wild, een baby alligator vasthouden of een show bijwonen. Lees meer over de verschillende opties op de Everglades Alligator Farm.[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf $25 dollar per persoon[/ultimate_icon_list_item][/ultimate_icon_list][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Feverglades.com%2Fairboat-rides%2F|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612946867021{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Alligators in de Everglades\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">Florida is de beste plek in Amerika om alligators te zien in het wild, het wordt niets voor niets alligator state genoemd. Er leven meer dan 1,5 miljoen alligators in de staat Florida. Ondanks dat de <a href=\"https://www.heyusa.com/nl/everglades-national-park/\">Everglades</a> het grootste nationale park is van de staat, leven daar maar 200.000 alligators. Desondanks een goede plek om de grootste reptiel van Noord Amerika te zien. Het zoete water van de Everglades is de perfecte thuisbasis voor de alligator die leeft van vogels, schildpadden en slangen. En of ze ook mensen eten? In principe niet, maar een alligator zal er alles aan doen om zichzelf en eventuele jongen te beschermen.\u00a0</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1640066907439{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"300px\"][vc_custom_heading text=\"Everglades Alligator Farm\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"De plek om alligators te zien\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"300px\"][parallax_row opacity=\"90\" enable_mobile=\"parallax-enable-mobile\" image=\"10788\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Airboat Rides Alligator Farm\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Een van de leukste en meest veiligste manieren om alligators in het wild te zien is per airboat. Met een ticket voor de airboat kun je ook de Alligator Farm bezoeken waarbij je een alligator show en het voeden kunt bekijken. Met de airboat ga je in ongeveer 20-25 minuten door de Everglades op zoek naar alligators. Hoewel je geen garantie krijgt om ze te zien, zijn er ervaren gidsen mee die vaak weten waar ze zich ophouden. Want alligators in het wild zien, geeft toch net even wat extra's dan in een dierentuin of op de Alligator Farm.</span>[/vc_column_text][ultimate_heading main_heading=\"Vanaf $31\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_margin=\"margin-top:5px;margin-bottom:5px;\"][/ultimate_heading][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Feverglades.com%2Fairboat-rides%2Fairboat-ride-general-admission%2F|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Alligator Encounter\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Oog in oog met een alligator, je moet het maar durven! Bij de Alligator Encounter heb je de mogelijkheid tot het vasthouden van baby alligators of alligators tot een meter groot. In deze 1 uur durende tour kun je naast het vasthouden van alligators ook de voedershow bijwonen. In de vijver zwemmen meer dan 250 alligators. De kans om op een veilige manier van dicht bij kennis te maken met een alligator.[/vc_column_text][ultimate_heading main_heading=\"Vanaf $100\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_margin=\"margin-top:5px;margin-bottom:5px;\"][/ultimate_heading][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Feverglades.com%2Fprices-tours%2Falligator-encounter%2F|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Bezoek Alligator Farm Everglades\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Je kunt ook Alligator Farm bezoeken zonder allerlei activiteiten. Gedurende de dag zijn er een aantal shows te bekijken en worden er ook diverse voedershows gehouden. De alligator show is een van de meest spectaculaire shows om bij te wonen. Ook de voedershow is erg vermakelijk om te zien, honderden alligators die vechten om voedsel.[/vc_column_text][ultimate_heading main_heading=\"Vanaf $25\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_margin=\"margin-top:5px;margin-bottom:5px;\"][/ultimate_heading][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Feverglades.com%2Fshows%2F|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Oog in oog met een alligator\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Durf jij het aan?\" font_size=\"40\" line_height=\"40\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"10787\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tickets voor Everglades Alligator Farm\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Verschillende mogelijkheden voor tickets\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Om de Alligator Farm in de Everglades te bezoeken kun je verschillende tickets aanschaffen. De reguliere airboat tickets heb je vanaf $31, je kunt ook kiezen voor een private tour ($400).\u00a0 Wil je een alligator van dichtbij bekijken? Dat kan vanaf ongeveer 100 euro.</span>\r\n\r\nDe Alligator Farm behoort ook tot een van de activiteiten die je met de Miami City Pass kunt ondernemen.\r\nLees meer over de <a href=\"https://www.heyusa.com/nl/voordeelpassen-miami/\">Miami City Pass</a> en welke activiteiten je nog meer kunt ondernemen.[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Feverglades.com%2Fairboat-rides%2Fairboat-ride-general-admission%2F|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"1/2\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ult_buttons btn_title=\"Lees meer over de Miami City Pass\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fvoordeelpassen-miami%2F|title:Voordeelpassen%20Miami\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie Alligator Farm\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>40351 Southwest 192nd Avenue - Homestead, Florida</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Dagelijks van 9.30-17.30 uur</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<strong>Openingstijden kunnen afwijken tijdens Kerst en Oud en Nieuw</strong>[/ultimate_icon_list_item][/ultimate_icon_list][vc_custom_heading text=\"Wat is het beste moment om de Alligator Farm te bezoeken?\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In principe kun je het hele jaar alligators zien in de Everglades. Echter zijn de wintermaanden de periode waarin het lastiger is om alligators in het wild te zien. De waterstand is dan laag en de alligators zitten meer verstopt. De lente en de zomer zijn de beste periode.[/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Foto's alligators in de Everglades\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][thb_image_slider images=\"10788,10787,4734,9844,4732,4735\"][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Miami\" font_container=\"tag:div|font_size:50|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|categories:168\"][/vc_column][/vc_row]","post_title":"Everglades Alligator Farm","post_link":"https://www.heyusa.com/nl/everglades-alligator-farm/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Everglades NP\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/03/Everglades3-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Miami","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1612946867021{background-color: #ededed !important;}.vc_custom_1640066907439{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}","%_edit_last%":"2","%_edit_lock%":"1685445572:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"4735","%_yoast_wpseo_focuskw%":"Everglades Alligator Farm","%_yoast_wpseo_title%":"Everglades Alligator Farm Florida %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Everglades Alligator Farm is een van de must do attracties in het Everglades National Park. Stap in de boot om alligators te zien in de Everglades.","%_yoast_wpseo_linkdex%":"77","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"alligators florida\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"40351 SW 192nd Ave, Homestead, FL 33034, Verenigde Staten","%_wpgmp_location_city%":"Homestead","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.393168","%_wpgmp_metabox_longitude%":"-80.5012007","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"168","%_yoast_indexnow_last_ping%":"1685445696","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Bezienswaardigheden Miami","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":10779,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Hop on Hop off Miami","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hop on Hop off Miami\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/02/miami-big-bus-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Hop on Hop off Miami</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1680 Washington Ave, Miami Beach, FL 33139, Verenigde Staten","location":{"lat":"25.7916822","city":"Miami Beach","state":"Florida","country":"Verenigde Staten","lng":"-80.1320489","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/hop-on-hop-off-miami/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Ontdek Miami met de Hop on Hop off\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Nieuw in een stad en benieuwd hoe de stad er eigenlijk uit ziet en waar alle bezienswaardigheden zich bevinden? Een handige en ook nog eens leuke manier om een stad te ontdekken is per Hop on Hop off. Stap in de Big Bus die je langs de belangrijkste bezienswaardigheden van Miami brengt, waar je uit kan stappen om deze te bezoeken en vervolgens weer in kunt stappen om weer verder de stad te bekijken, ideaal! En in een stad als Miami ook nog een praktisch, want met mooi weer in een open bus door de stad is een heerlijke manier van sightseeing.[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]Hele jaar door[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf \u20ac43[/ultimate_icon_list_item][/ultimate_icon_list][ult_buttons btn_title=\"Boek je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fmiami-beach-l33437%2Fmiami-hop-on-hop-off-bus-tour-biscayne-bay-boat-tour-t61876%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dmiamibigbus|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Stap in de Hop on Hop off in Miami\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">Bezoek de beste attracties en bezienswaardigheden van Miami en wordt voor de deur afgezet. Per Hop on Hop off reizen in een stad kan ontspannen zijn, je ziet de highlights van de stad en kunt uitstappen waar je wil. Bij de Hop on Hop off in Miami kom je door wijken als Little Havana, South Beach, Coconut Grove, Downtown Miami en Wynwood; zie het beste van de stad met het gemak van een touringbus. De Hop on Hop off biedt je mogelijkheden tot extra's als het bijboeken van een boottocht door Biscayne Bay, de <a href=\"https://www.heyusa.com/nl/everglades-national-park/\">Everglades</a> of de Miami Night Tour.</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Hop on Hop off Miami\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\" margin_design_tab_text=\"\"][/ultimate_heading][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Al tourend Miami verkennen!\" font_size=\"40\" line_height=\"40\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"10772\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tickets voor de Hop on Hop off in Miami\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Tickets voor de Hop on Hop off kun je het beste al online kopen. Je hebt drie verschillende opties voor Miami:\r\n<ol>\r\n \t<li>Hop on Hop off ticket voor 1 dag</li>\r\n \t<li>Hop on Hop off ticket voor 1 dag inclusief rondvaart</li>\r\n \t<li>Hop on Hop off ticket voor 2 dagen inclusief rondvaart en de Everglades</li>\r\n</ol>\r\n[/vc_column_text][ult_buttons btn_title=\"Boek je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fmiami-beach-l33437%2Fmiami-hop-on-hop-off-bus-tour-biscayne-bay-boat-tour-t61876%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dmiamibigbus2|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>Ieder halte, wissel wel eerst de voucher om!</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Tussen 9.15 uur en 17.15 uur</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"De open Big Bus\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Geniet ondertussen van het zonnetje in Miami\" font_size=\"40\" line_height=\"40\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"10774\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space][fullwidth_row][vc_custom_heading text=\"Andere interessante artikelen\" font_container=\"tag:div|font_size:65|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"size:4|order_by:date|order:DESC|post_type:post|by_id:7537,4725,3764,9784\"][/vc_column][/vc_row]","post_title":"Hop on Hop off Miami","post_link":"https://www.heyusa.com/nl/hop-on-hop-off-miami/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hop on Hop off Miami\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/02/miami-big-bus-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Miami","post_tags":"Florida","%_wpb_shortcodes_custom_css%":".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}","%_edit_last%":"2","%_edit_lock%":"1684835213:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Hop on Hop off Miami","%_yoast_wpseo_metadesc%":"De Hop on Hop off Miami is een leuke manier om de stad te verkennen. Tips voor het nemen van de Hop on Hop off Miami.","%_yoast_wpseo_linkdex%":"74","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"1680 Washington Ave, Miami Beach, FL 33139, Verenigde Staten","%_wpgmp_location_city%":"Miami Beach","%_wpgmp_location_state%":"Florida","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"25.7916822","%_wpgmp_metabox_longitude%":"-80.1320489","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_thumbnail_id%":"10773","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"168","%_yoast_indexnow_last_ping%":"1684835211","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Bezienswaardigheden Miami","taxonomy=post_tag":"Florida","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":10769,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Tickets Summit One Vanderbilt","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Summit One Vanderbilt\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/02/Summit-One-Vanderbilt1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Tickets Summit One Vanderbilt</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"45 E 42nd St, New York, NY 10017, Verenigde Staten","location":{"lat":"40.752764","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.9787461","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/summit-one-vanderbilt/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Tickets Summit One Vanderbilt - de meest instagrammable plek van New York\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Summit One Vanderbilt in New York is meer dan een uitkijkplatform, het is een ware belevenis met ondertussen een panoramisch uitzicht over New York. Naast het Grand Central Station vind je de One Vanderbilt wolkenkrabber. Op de 91e tot 93e etage is de Summit One Vanderbilt, een unieke combinatie tussen een prachtig uitzicht met een ware belevenis. Benieuwd naar deze experience? Boek dan snel je <a href=\"https://www.getyourguide.nl/new-york-l59/nyc-summit-een-vanderbilt-experience-ticket-t404501/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=summitintrotekst\" target=\"_blank\" rel=\"noopener\">tickets voor een bezoek aan de Summit One Vanderbilt</a>.[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-arrows-v\"]Platform op 305 meter hoogte[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-building\"]Tussen verdieping 91 en 93[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-calendar\"]5 dagen per week geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]\r\n\r\nVanaf \u20ac42 per persoon\r\n\r\n[/ultimate_icon_list_item][/ultimate_icon_list][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fnyc-summit-one-vanderbilt-experience-ticket-t404501%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dsummitoneheader|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"New York in spiegelbeeld\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Instagrammable plek in NYC\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fnew-york-l59%2Fnyc-summit-een-vanderbilt-experience-ticket-t404501%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26cmp%3Dsummitbanner|title:Tickets%20voor%20Summit|target:_blank\" btn_align=\"ubtn-center\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"10756\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tickets voor Summit One Vanderbilt in New York\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\"><a href=\"https://www.getyourguide.com/new-york-city-l59/nyc-summit-one-vanderbilt-experience-ticket-t404501/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=summitoneotekst\" target=\"_blank\" rel=\"noopener\">Tickets</a> voor Summit One Vanderbilt heb je vanaf $42. Hiervoor heb je de SUMMIT Experience. Wil je ook toegang tot de glazen lift de Ascent? Dan heb je tickets vanaf $62.</span>[/vc_column_text][vc_custom_heading text=\"Tips voor je bezoek aan Summit One Vanderbilt\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_column_text]Een bezoek aan Summit One Vanderbilt brengt enige voorbereiding met zich mee. Zo zijn jurkjes en rokken niet handig om te dragen en ook schoeisel met hakken zijn niet toegestaan vanwege eventuele beschadiging aan de vloer. Door de vele ramen en spiegels is het handig om een zonnebril mee te nemen.[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fnyc-summit-one-vanderbilt-experience-ticket-t404501%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dsummitoneonderin|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie Summit One Vanderbilt\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>45 E 42nd Street naast Grand Central Station</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Woensdag &amp; Donderdag 13:00-21:00 uur\r\nVrijdag &amp; Zaterdag: 9:00 - 23:00 uur\r\nZondag: 10:00-21:00 uur</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<strong>Openingstijden kunnen afwijken tijdens Kerst en Oud en Nieuw</strong>[/ultimate_icon_list_item][/ultimate_icon_list][vc_custom_heading text=\"Wat is het beste moment om Summit One Vanderbilt te bezoeken?\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het bezoeken van de Summit overdag of 's avonds kan een lastige keuze zijn. Overdag zie de stad in volle glorie want je hebt een perfect uitzicht over de skyline. In de avond wordt de ervaring van Summit in combinatie met de lichten van de stad intenser.[/vc_column_text][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612946867021{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Over Summit One Vanderbilt in New York\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">Op de 427 meter hoge One Vanderbilt wolkenkrabber vind je niet alleen een observatieplatform (op 305 meter), je ondergaat een complete experience in de Summit One Vanderbilt. Door de combinatie van vele spiegels en kunst is het misschien wel een van de leukste Instagrammable plekken \u00e9n observatieplatformen van New York. Op drie verdiepingen vind je een combinatie tussen beeld en geluid. Binnen vind je een caf\u00e9 met open haard en ook is er een buitenterras. Vanaf Summit One Vanderbilt heb je misschien wel een van de mooiste uitzichten over New York.\u00a0</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Transcendence\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Wat direct opvalt wanneer je binnenkomt in Transcendence is de grote hoeveelheid spiegels. Hoge plafonds, wanden en vloeren allemaal bedekt met spiegels. Een broek is dan ook een veilige keuze bij een bezoek aan Summit One Vanderbilt ;) Dit is wel de plek om toffe foto's te maken van New York in combinatie met alle spiegels.</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Affinity\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Wanneer je doorloopt kom je in de ruimte die Affinity genoemd wordt. Hier zweven honderden zilveren ballonnen rond. Omringd door de ballonnen heb je ondertussen een uitzicht over Central Park en Uptown Manhattan. En weer een unieke plek om foto's te maken van de skyline van New York.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Levitation\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Natuurlijk kan een 'echt' observatieplatform niet ontbreken op een wolkenkrabber als One Vanderbilt. Er zijn twee plekken waar je letterlijk boven de stad loopt en waar je onder je de mensen ziet lopen. Staan op een glazen vloer op ruim 300 meter hoogte moet je ook maar durven.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Enjoy the view!\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Uitzicht vanaf Summit One Vanderbilt in combinatie met honderden ballonnen\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"10760\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1620887540936{background-color: #dadada !important;}\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][ultimate_heading main_heading=\"Veelgestelde vragen over Summit One Vander Bilt\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:800;\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][vc_toggle title=\"Wat kost een ticket voor The Summit?\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]Je hebt tickets vanaf 42 euro.[/vc_toggle][vc_toggle title=\"Hoe hoog is Summit New York\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]De totale lengte van de Summit is 427 meter, het uitkijkplatform bevindt zich op 305 meter[/vc_toggle][vc_toggle title=\"Wat is de beste tijd om The Summit te bezoeken?\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]Voor The Summit is er geen beste tijd. Het is op ieder moment een leuke ervaring.[/vc_toggle][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"80%\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Foto's van Summit One Vanderbilt\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][thb_image_slider images=\"10762,10761,10759,10760,10758,10757,10756,10755\"][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York\" font_container=\"tag:h2|font_size:50|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:-3408,-1759,1484,-520,1559,10251,1571\"][/vc_column][/vc_row]","post_title":"Tickets Summit One Vanderbilt","post_link":"https://www.heyusa.com/nl/summit-one-vanderbilt/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Summit One Vanderbilt\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/02/Summit-One-Vanderbilt1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden New York","post_tags":"New York","%_wpb_shortcodes_custom_css%":".vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1612946867021{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1620887540936{background-color: #dadada !important;}","%inline_featured_image%":"0","%_edit_last%":"2","%_edit_lock%":"1690791119:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"14","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"10754","%_yoast_wpseo_focuskw%":"Tickets Summit One Vanderbilt","%_yoast_wpseo_title%":"Tickets Summit One Vanderbilt in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Summit One Vanderbilt in New York is een van de highlights in New York. Boek tickets voor Summit One Vanderbilt in New York.","%_yoast_wpseo_linkdex%":"79","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Summit One Vanderbilt New York\"]","%_wpgmp_location_address%":"45 E 42nd St, New York, NY 10017, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.752764","%_wpgmp_metabox_longitude%":"-73.9787461","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%post_via%":[{"title":"Summit One Vanderbilt // NYC & Company","post_source_url":"nycgo.com"},{"title":"","post_source_url":""}],"%_yoast_indexnow_last_ping%":"1690447092","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_primary_category%":"","taxonomy=category":"Bezienswaardigheden New York","taxonomy=post_tag":"New York","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":10752,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Graceland in Memphis","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Graceland in Tennessee bezoeken\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/01/graceland-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Graceland in Memphis</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"3764 Elvis Presley Blvd, Memphis, TN 38116, Verenigde Staten","location":{"lat":"35.0459411","city":"Memphis","state":"Tennessee","country":"Verenigde Staten","lng":"-90.0229481","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/graceland-memphis/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Graceland in Memphis bezoeken\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Wie kent hem niet: Elvis Presley, de King of Music. Inmiddels is de plek waar een van de beroemdste zangers uit de geschiedenis van Amerika heeft gewoond, het bedevaartsoord van Amerika. Voor fans en niet-fans een must do om te bezoeken wanneer je in Tennessee bent. Graceland is lekker over-the-top Amerikaans, maar zeg nou zelf, het huis waar Elvis Presley gewoond heeft kun je toch echt niet overslaan? Tips om Graceland in Memphis te bezoeken.[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]363 dagen per jaar geopend muv Thanksgiving en Christmas[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf \u20ac46 per persoon[/ultimate_icon_list_item][/ultimate_icon_list][ult_buttons btn_title=\"Bestel je VIP tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fnashville-tennessee-l1279%2Fvip-tour-van-nashville-naar-graceland-memphis-t21346%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26cmp%3Dgracelandvipboven\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612946867021{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Waar ligt Graceland?\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">In de wijk Whitehaven in <a href=\"https://www.heyusa.com/nl/wat-doen-in-memphis/\">Memphis</a> (Tennessee) ligt het voormalige landgoed van Elvis Presley. Op 3764 Elvis Presley Boulevard woonde de King of Music van 1957 tot aan zijn dood in 1977. Hij kocht het huis voor 100.000 dollar en ging er samen met zijn ouders wonen, zo kon hij de belofte inlossen. Uiteindelijk bleek Graceland zo groot dat zelfs vrienden van hem er kwamen wonen. Elvis Presley was op deze manier niet alleen de King of Pop, hij was ook het ultieme voorbeeld van de Amerikaanse droom; een arme jongen uit de kleine stad Tupelo, die superster werd en de popmuziek veranderde. Graceland is na zijn dood een bedevaartsoord geworden voor fans van Elvis, maar ook als je minder fan bent is Graceland een indrukwekkende plek.</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Het graf van Elvis Presley\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_empty_space height=\"25px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Een van de meest indrukwekkende plekken\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"10494\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Heilige grond\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Graceland is een populaire bezienswaardigheid in Memphis en wordt gezien als heilige grond. Gelukkig voor jou mag die bezocht worden. Met een shuttle busje word je afgezet op de oprijlaan van het huis. Ondertussen moet je niet raar opkijken als je tussen de nep-Elvissen loopt. Bezoekers mogen alleen de begane grond bekijken, de bovenverdieping is gesloten voor publiek. Je loopt voetje voor voetje door de woonkamer, de spelletjeskamer, de slaapkamer en badkamer van Elvis. De laatste twee zijn nog in originele staat met bijvoorbeeld de tandpasta en eau de cologne van Elvis nog op het plankje. In het huis vind je veel prullaria waar Elvis dol op was, zijn knuffelpanda staat er nog. Natuurlijk kan een bezoek aan de trophy kamer niet ontbreken, alle prijzen die Elvis gewonnen heeft staan hier inclusief een aantal kostuums. </span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Het Graceland terrein\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Niet alleen het huis is bijzonder, het wordt nog veel indrukwekkender wanneer de toer naar buiten gaat. Het enorme terrein rondom het huis is inmiddels verdubbeld, maar je vindt er nog de originele ruimtes als de tennisbaan, zwembad, paardenstallen en de weides. De plek die het meest indruk maakt is de meditation garden waar je het graf van Elvis vindt. Meerdere tranen worden hier dan ook gelaten door bezoekers. Op de ruimtes die er in de loop van de jaren bijgekomen zijn, kun je het winkelcentrum, bioscoop, tentoonstellingen en het automuseum bezoeken. Ook zijn prive vliegtuig Lisa Marie staat op het terrein.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Fun Fact over Elvis\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Elvis was fan van vaste producten in huis, hij had een lijst met daarop dingen die hij altijd in huis wilde hebben. Daarop stonden onder andere:\r\n<ul>\r\n \t<li>Mosterd</li>\r\n \t<li>Drie flessen melk</li>\r\n \t<li>American Footbal Magazine</li>\r\n \t<li>Alles voor een banana-jam-peanutbutter sandwich</li>\r\n \t<li>Bananenpudding</li>\r\n \t<li>Vers gemaakte brownies</li>\r\n \t<li>3 pakken kauwgum - verschillende smaken</li>\r\n \t<li>Hamburgerbroodjes</li>\r\n \t<li>Een door candybars (mars, snickers etc)</li>\r\n \t<li>Een kist voor Pepsi en Sinas</li>\r\n \t<li>Dozen met broodjes</li>\r\n \t<li>Ten minste 6 bakken met koekjes</li>\r\n \t<li>Aardappels en uien</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Dwaal door het huis van de King of Pop\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_empty_space height=\"25px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"De Trophy room met alle prijzen en Elvis pakken\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"10496\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tickets voor Graceland in Memphis\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Verschillende soorten tickets voor Graceland\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Tickets kun je voorafgaand aan je bezoek aan Memphis al kopen, bijvoorbeeld als je op een specifieke datum en tijd Graceland wilt bezoeken, maar er zijn ook tickets bij Graceland Ticket Office. Er zijn verschillende prijscategorie\u00ebn voor het kopen van tickets. Voor de <strong>ultimate VIP tour</strong> ben je ongeveer $260 kwijt, maar je kunt ook de <strong>Elvis Experience tour tickets</strong> aanschaffen, deze heb je vanaf $46.\u00a0</span>[/vc_column_text][ult_buttons btn_title=\"Bestel je VIP tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fnashville-tennessee-l1279%2Fvip-tour-van-nashville-naar-graceland-memphis-t21346%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26cmp%3Dgracelandviponder\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_custom_heading text=\"Overnachten in de buurt van Graceland\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">In de buurt van Graceland overnachten? Dat kan. Je hebt verschillende opties waaronder het <a href=\"https://guesthousegraceland.com/\" target=\"_blank\" rel=\"noopener\">Heartbreak Hotel</a>, <a href=\"https://www.graceland.com/rv-park-campground\" target=\"_blank\" rel=\"noopener\">Graceland RV Park</a> en <a href=\"https://www.booking.com/hotel/us/super-8-memphis-downtown-graceland-area.en.html?aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=gracelandsuper8graceland\" target=\"_blank\" rel=\"noopener\">Super 8 by Wyndham</a></span>[/vc_column_text][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie Graceland\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>3764 Elvis Presley Boulevard Memphis</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Dagelijks van 09.00 uur tot 16.00 uur</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<strong>Openingstijden kunnen afwijken tijdens Thanksgiving, Kerstavond en 1e Kerstdag</strong>[/ultimate_icon_list_item][/ultimate_icon_list][vc_custom_heading text=\"Wat is het beste moment om Graceland te bezoeken?\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Graceland is 363 dagen per jaar geopend van 09.00 uur tot een uurtje of 16.00 Wanneer je rond 14.00 uur Graceland gaat bezoeken is het vaak al een stukje rustiger. Je hebt dan nog zo'n 2 uur de tijd om te genieten van de Elvis Experience.\r\n\r\nJe hebt de mogelijkheid om het graf van Elvis in de Meditation Garden gratis te bezoeken. De tijden daarvoor zijn dagelijks van 7.30 uur tot 8.30 uur. Je moet de tuin weer verlaten voordat de Graceland Tours gaan starten. Overigens is dit niet mogelijk op Thanksgiving en Christmas Day.[/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Foto's van Graceland\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][thb_image_slider images=\"10498,10497,10495,10493,10494,10496\"][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen\" font_container=\"tag:div|font_size:50|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:11841,11027,3692,8105\"][/vc_column][/vc_row]","post_title":"Graceland in Memphis","post_link":"https://www.heyusa.com/nl/graceland-memphis/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Graceland in Tennessee bezoeken\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2022/01/graceland-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden","post_tags":"Tennessee","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1612946867021{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"2","%_edit_lock%":"1709028711:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"14","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":[{"title":"Foto credit: Julienne Schaer/NYC & Company","post_source_url":"http://www.nycgo.com"}],"%_thumbnail_id%":"10498","%_yoast_wpseo_focuskw%":"Graceland in Memphis bezoeken","%_yoast_wpseo_title%":"Graceland in Memphis bezoeken %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Het bedevaartsoord voor fans van Elvis Presley: Graceland. Alles wat je moet weten om Graceland in Memphis bezoeken.","%_yoast_wpseo_linkdex%":"71","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Graceland Memphis\"]","%_wpgmp_location_address%":"3764 Elvis Presley Blvd, Memphis, TN 38116, Verenigde Staten","%_wpgmp_location_city%":"Memphis","%_wpgmp_location_state%":"Tennessee","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"35.0459411","%_wpgmp_metabox_longitude%":"-90.0229481","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"65","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1709028644","%_last_editor_used_jetpack%":"classic-editor","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","taxonomy=category":"Bezienswaardigheden","taxonomy=post_tag":"Tennessee","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":10475,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Grand Teton National Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Nationale parken in Amerika die op je bucketlist horen\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/01/Grand-Teton-NP-2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Grand Teton National Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Wyoming, Verenigde Staten","location":{"lat":"43.7904282","state":"Wyoming","country":"Verenigde Staten","lng":"-110.6817627","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/grand-teton-national-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Grand Teton National Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De bergketen de Grand Teton Mountains vormden de aanleiding om het gebied om te dopen tot een nationaal park. Logischerwijs is de Grand Teton de grootste met meer dan 4000 meter, maar ook de andere bergen doen niet onder voor deze berg. Er zijn meer dan 12 pieken met een hoogte van 3650 meter. Grand Teton National Park heeft ruim 130.00 hectare aan oppervlakte, maar beslaat eigenlijk nog een groter gebied door de staatsbossen en wildreservaten in de directe omgeving. Kortom een enorm veelzijdig park met veel mogelijkheden tot wandelen en het zien van wildlife. Alle tips voor een bezoek aan het Grand Teton National Park.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]450 kilometer vanaf Salt Lake City[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">1255 km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-paw\"]500 verschillende soorten dieren[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-leaf\"]<span class=\"LrzXr kno-fv\">meer dan 1000 verschillende soorten bomen en planten</span>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Grand Teton Mountains\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">De bergen van de Grand Teton Mountains zijn een relatief jong gebergte, ze zijn zelfs een van de jongste in de Rockies. Ongeveer 9 tot 10 miljoen jaren geleden begonnen in dit gebied twee platen te schuiven. Het oostelijke deel van het gebied werd omlaag gedrukt en in het westen ontstonden de bergen. Het maffe is dat het proces nog steeds bezig is, de hoogtes van de bergen veranderen nog steeds en de vallei wordt steeds lager.</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Jackson Hole vallei\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Als laatste toegevoegd aan Grand Teton NP\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"10098\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Facts Grand Teton National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Grand Teton National Park is in de loop der jaren groter geworden. Bij de oprichting in 1929 bestond het gebied alleen uit bergtoppen en enkele gletsjermeren. Door allerlei problemen werd het park pas in 1943 uitgebreid. In eerste instantie werd Jackson Hole uitgeroepen tot Nationaal Monument dat in 1950 samen werd gevoegd met het al bestaande deel van het Grand Teton National Park. Daardoor beslaat Grand Teton National Park nu ook delen van Jackson Hole, enkele heuvels, Jackson Lake en Teton Range. Ook het 13.500 hectare deel dat van de familie Rockefeller was kon toegevoegd worden aan het park.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Hoogtepunten in Grand Teton National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Grand Teton National Park is op te delen in 2 gebieden: Jackson Hole vallei en de Teton Range. De Jackson Hole vallei is het meest bezochte gebied van het park. Vanuit de vallei kun je de bergen van de Grand Tetons aanschouwen. Highway 89 en de Teton Park Road lopen dwars door het park en op beide wegen heb je diverse mogelijkheden om te stoppen voor uitzichtpunten. Naast het grote Jackson Lake bevat Grand Teton National Park nog een meer, het populaire Jenny Lake. In de zomermaanden vaak de drukste plek in het park, vanwege het uitzicht en vanwege de watersport-mogelijkheden. Een andere reden waarom Grand Teton de moeite waard is, is de grote kans op het zien van vele wilde dieren.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten in het Grand Teton National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Overnachten in Grand Teton National Park kan in een van de hotels of op een van de vijf campings. Deze laatste zijn van met/juni tot september/oktober geopend. Voordat je afreist naar Grand Teton National Park is het handig om een alternatief achter de hand te hebben voor een camping, ze zijn namelijk allemaal erg populair en soms rond het middaguur al vol. De beste camping om dan nog een plek te vinden is Gros Ventre Campground in het zuidoosten van Grand Teton National Park.\r\n\r\n<strong>Hotels</strong>\r\n\r\nOvernachten in Grand Teton National Park zelf is duur. Zeker de <a href=\"https://www.booking.com/hotel/us/jackson-lake-lodge.en.html?aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=grandtetonjacksonlake\" target=\"_blank\" rel=\"noopener\">Jackson Lake Lodge</a>, <a href=\"https://www.signalmountainlodge.com/\" target=\"_blank\" rel=\"noopener\">Signal Mountain Lodge</a> en de <a href=\"https://www.gtlc.com/lodges/jenny-lake-lodge\" target=\"_blank\" rel=\"noopener\">Jenny Lake Lodge</a> zijn aan de prijs. Andere opties om te overnachten zijn de <a href=\"https://trianglex.com/\" target=\"_blank\" rel=\"noopener\">Triangle X Ranch</a>, <a href=\"https://www.booking.com/hotel/us/togwotee-mountain-lodge.en.html?aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=grandtetontowotee\" target=\"_blank\" rel=\"noopener\">Togwotee Mountain Lodge</a>, <a href=\"https://www.booking.com/hotel/us/headwaters-lodge-amp-cabins-at-flagg-ranch.en.html?aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=grandtetonheadwaters\" target=\"_blank\" rel=\"noopener\">Headwaters Lodge &amp; Cabins at Flagg Ranch</a>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reisperiode Grand Teton National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De wintermaanden zijn vaak een lange periode met koude winters, temperaturen van -15 \u00b0 C zijn niet ongewoon. Ook een dikke pak sneeuw ontbreekt niet in deze periode. Pas eind mei zijn de meeste paden sneeuwvrij. De zomermaanden zijn de beste periode om een bezoek te brengen aan Grand Teton National Park met temperaturen van 25 graden, overigens heb je in de avonden wel kans op onweer.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Jenny Lake\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"Het populairste meer in het gebied\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"10100\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelingen &amp; trails\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]Grand Teton National Park is een walhalla voor wandelliefhebbers. Er zijn vele trails die gelopen kunnen worden, in totaal meer dan 300 kilometer aan wandelpaden. Onderweg hoef je je niet te vervelen met een enorme diversiteit aan uitzichten op gletsjermeren, bergtoppen of helder blauwe meren. Er zijn wandelingen voor iedere soort wandelaar, van moeilijke en uitdagende trails tot makkelijke wandelingen over vlakke paden. Die laatste vind je vooral in de Colter Bay.[/vc_column_text][ultimate_heading main_heading=\"Hidden Falls Trail\" heading_tag=\"h3\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]Een van de mooiste en daardoor direct ook populairste wandeling in het Grand Teton National Park is de Hidden Falls Trail. Het is de enige waterval die toegankelijk is om te bezoeken. Om de trail te bereiken moet je de boot pakken op Jenny Lake of rondom het hele meer lopen. De Hidden Falls is ongeveer 80 meter hoog en het water komt in een aantal etappes naar beneden. Het totale rondje is niet erg groot, 1,6 kilometer, maar kun je eventueel uitbreiden met de Inspiration Point Trail waardoor je rondje op 2,6 kilometer komt. Ga je wandelend in plaats van met de boot, dan kun je er 6 a 7 kilometer bij op doen.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]24/7 en 365 dagen geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: zomer[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]7 daagse pas met auto of camper: $35[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-ticket\" content_font_size=\"desktop:16px;\"]$20 per persoon voor 7 dagen[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-location-arrow\" content_font_size=\"desktop:16px;\"]Meer dan 300 kilometer aan wandelpaden[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Hidden Falls Trail\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"E\u00e9n van de populairste wandelingen in Grand Teton\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"10099\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Meer nationale parken\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:4738,4714,4689,4792\"][/vc_column][/vc_row]","post_title":"Grand Teton National Park","post_link":"https://www.heyusa.com/nl/grand-teton-national-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Nationale parken in Amerika die op je bucketlist horen\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/01/Grand-Teton-NP-2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Grand Teton National Park","post_tags":"Wyoming","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_lock%":"1664700308:2","%_edit_last%":"1","%_thumbnail_id%":"3687","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Grand Teton National Park","%_yoast_wpseo_metadesc%":"Ten zuiden van Yellowstone vind je nog een prachtig park: Grand Teton National Park. Alle tips voor een bezoek aan Grand Teton National Park.","%_yoast_wpseo_linkdex%":"80","%_wpgmp_location_address%":"Wyoming, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Wyoming","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"43.7904282","%_wpgmp_metabox_longitude%":"-110.6817627","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%_yoast_wpseo_primary_category%":"165","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1677015151","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Grand Teton National Park","taxonomy=post_tag":"Wyoming","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png"},"id":10097,"infowindow_disable":false},{"source":"post","title":"Shenandoah National Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Shenandoah National Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/12/shenandoah-national-park-mist-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Shenandoah National Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Virginia, Verenigde Staten","location":{"lat":"38.4754706","state":"Virginia","country":"Verenigde Staten","lng":"-78.4534573","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/shenandoah-national-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Shenandoah National Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Shenandoah National Park is een must om in de herfst te bezoeken. Natuurlijk is het park in andere jaargetijden ook prachtig, maar de herfstkleuren maken het park net iets specialer. De Indian Summer op zijn best. Shenandoah National Park is onderdeel van de Blue Ridge Mountains en wordt vaak bezocht door mensen die de Blue Ridge Parkway route rijden. Het heuvelachtige landschap biedt veel uitkijkplaatsen om de Shenandoah Valley te bekijken. In het park zelf vind je veel bossen, rivieren en watervallen. Tel daar de wilde dieren en de vele vogels nog bij op en je hebt alles wat je wil voor een bezoek aan het nationaal park.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]115 kilometer vanaf Washington D.C.[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">806 km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-paw\"]40 verschillende soorten zoogdieren[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-leaf\"]<span class=\"LrzXr kno-fv\">meer dan 250 verschillende soorten bomen</span>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Vogels en wildlife bekijken\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Shenandoah National Park is een van de beste plekken om vogels en wildlife te zien in Amerika. Soms hoef je niet eens te zoeken naar bijvoorbeeld beren of herten en steken ze de Skyline Drive over. In het park kun je meer dan 200 verschillende vogels zien of wat denk je van 40 verschillende soorten zoogdieren. De beste plekken om wildlife te zien? Bij Rockfish Gap kun je haviken spotten en bij Big Meadows kun je beren, kalkoenen of herten zien.</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Skyline Drive\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"De 170 kilometer lange weg door Shenandoah National Park\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"10092\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Facts Shenandoah National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het gebied dat onderdeel is van de Blue Ridge Mountains kreeg in 1936 de offici\u00eble naam Shenandoah National Park door President Roosevelt. Dit ging echt niet helemaal zonder problemen. Deze regio was het ultieme gebied voor mensen die de steden wilden ontvluchten. In 1926 werd de eerste poging gedaan om het gebied een nationaal park te noemen, het duurde dus uiteindelijk 10 jaar voordat het lukte om voor de inwoners een nieuwe plek te zoeken. Daarna was het nog de taak om het gebied dat over-begraast was terug te geven aan de natuur. Gelukkig lukte dat en inmiddels is er een grote populatie dieren en bloemen en planten te vinden.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Hoogtepunten in Shenandoah National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De beste manier om het park te verkennen is per auto via de Skyline Drive. Deze route van 170 kilometer loopt van noord naar zuid door het park. Langs deze route vind je tal van bezienswaardigheden en uitkijkpunten. Vanaf hier kun je verder het park in. Doordat wildlife, lees beren en herten, enigszins gewend zijn aan de mensen en auto's, hoef je soms niets eens je auto uit om deze te zien. Vanwege de toeristische weg en het wildlife mag je maar 35 mijl per uur rijden op de Skyline Drive, stiekem niet erg want zo kan ook de bestuurder enigszins genieten van de omgeving.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten in het Shenandoah National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Overnachten in Shenandoah National Park kan op verschillende manieren. De locaties liggen over het algemeen aan de Skyline Drive. Er zijn 5 campings waar je kunt staan waarvan de meesten een douche, wasserette en kampwinkel hebben (Matthews Arm niet). Voor Big Meadows in het zuiden heb je een reservering nodig, de rest werkt met het principe 'first come, first served'. Er zijn twee hotels waar je kunt overnachten: Skyland Resort en Big Meadows Lodge. In het noorden heb je de cabins van Lewis Mountains Cabins. En mocht je echt de wildernis in gaan zijn er diverse plekken hutten voor lange afstandswandelaars (backcountry permit nodig). Vaak worden deze gebruik door de wandelaars van de Appalachian Trail.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reisperiode Shenandoah National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het park is het gehele jaar geopend. In de wintermaanden kun je zelfs cross-country skien in het Shenandoah National Park. De meeste toeristen komen echt in het najaar naar het park. De reden? De kleuren van de bomen zijn dan het mooist, de Indian Summer is in volle gang. De lente begint pas in april mei en het is vaak net iets koeler en natter dan buiten het park. In de zomer kun je prima temperaturen treffen, maar heb je ook kans op heiige uitzichten. De campings in het park zijn geopend van mei tot en met eind oktober/half november.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Zwarte beren in Shenandoah\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"De beste plek om deze te zien is Big Meadows\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"10091\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelingen &amp; trails\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]Ondanks dat je een groot deel van je verblijf in Shenandoah National Park door gaat brengen op de Skyline Drive, is het mogelijk om te wandelen bij een van de stops aan de weg. Er is meer dan 800 kilometer aan wandelpaden te vinden in het park. Ruim 150 kilometer van het beroemde Appalachian Trail loopt door het Shenandoah National Park. Wil je een iets minder grote uitdaging? Dat kan natuurlijk ook. Er zijn verschillende kleuren op de bomen aangebracht om de routes aan te geven. Wit is voor de Appalachian Trail, geel en blauw voor wandelaars.[/vc_column_text][ultimate_heading main_heading=\"Whiteoak Canyon Trail\" heading_tag=\"h3\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]Een van de mooiste plekken in Shenandoah NP is Whiteoak Canyon. Verschillende watervallen, stroomversnellingen en rotsblokken zorgen ervoor dat dit een geliefd deel is van het park. De trail is officieel 7,4 kilometer in totaal, maar wil je alle 6 de watervallen zien, dan wordt de wandeling bijna 12 kilometer. Overigens is het wel een beetje klimmen bij deze trail, zo'n 600 meter hoogteverschil maar ;)[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]24/7 en 365 dagen geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: herfst[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]7 daagse pas met auto of camper: $30[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-ticket\" content_font_size=\"desktop:16px;\"]$15 per persoon voor 7 dagen[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-location-arrow\" content_font_size=\"desktop:16px;\"]45 dagwandelingen[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Herfst in Shenandoah NP\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"Indian Summer op zijn best\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"10089\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Meer nationale parken\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:4738,4714,4689,4792\"][/vc_column][/vc_row]","post_title":"Shenandoah National Park","post_link":"https://www.heyusa.com/nl/shenandoah-national-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Shenandoah National Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/12/shenandoah-national-park-mist-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Shenandoah National Park","post_tags":"Virginia","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_lock%":"1639127754:2","%_edit_last%":"1","%_thumbnail_id%":"10090","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Shenandoah National Park","%_yoast_wpseo_metadesc%":"In de staat Virginia vind je het Shenandoah National Park. Benieuwd wat te doen in Shenandoah National Park? Alle tips voor een bezoek aan Shenandoah.","%_yoast_wpseo_linkdex%":"72","%_wpgmp_location_address%":"Virginia, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Virginia","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.4754706","%_wpgmp_metabox_longitude%":"-78.4534573","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_primary_category%":"163","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1677015153","taxonomy=category":"Shenandoah National Park","taxonomy=post_tag":"Virginia","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png"},"id":10084,"infowindow_disable":false},{"source":"post","title":"Capitol Reef National Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Capitol Reef National Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/11/capitol-reef-national-park-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Capitol Reef National Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Utah, Verenigde Staten","location":{"lat":"38.0877312","state":"Utah","country":"Verenigde Staten","lng":"-111.1354983","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/capitol-reef-national-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Capitol Reef National Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het langgerekte en smalle Capitol Reef National Park ligt tussen Bryce Canyon NP en Canyonlands NP in, in de staat Utah. Net als de andere parken, zijn de rode rotsen, diepe canyons en kleurrijke kliffen kenmerkend voor Capitol Reef NP. Het park is minder bekend dan Zion en Bryce in Utah en wordt helaas onterecht vaak overgeslagen. Doordat het park niet groot is, kun je in een dag al veel zien. Vergeet vooral het indrukwekkende Waterpocket Fold niet te bekijken, hoewel je ook lastig om deze bezienswaardigheid heen kunt ;). Alle tips voor een bezoek aan Capitol Reef National Park.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]350 kilometer vanaf Salt Lake City[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">3242 km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-paw\"]60 verschillende soorten zoogdieren[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-leaf\"]<span class=\"LrzXr kno-fv\">16 verschillende soorten bomen</span>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Waterfold Pocket\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">De reden waarom je niet om Waterpocket Fold heen kunt, heeft te maken met de enorme omvang van deze rotsmuur. Met meer dan 160 kilometer, is het een van de meest spectaculaire geologische verschijnselen in Amerika. De eerste ontdekkers van Capitol Reef bij aanvang van de 20e eeuw waren gedwongen om hier te stoppen. Ze vonden het destijds lijken op een oceaanrif en dat de ronde, witte koepels iets weg hadden van het nationale Capitol Building in Washington - en voila was daar de naam van het nieuwe nationale park.</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Rotstekeningen\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Petrogliefen van de Fremont Cultuur\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"10040\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Facts Capitol Reef National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Grofweg kun je Capitol Reef opdelen in drie gebieden; Cathedral Valley in het noorden, Escarpment in het noordoosten en het plaatsje Fruita waar je het bezoekerscentrum vindt. Vanaf Highway 24, die dwars door het park loopt, kun je de meeste hoogtepunten bekijken. In Capitol Reef kom je nog veel oude petrogliefen tegen van de Fremont Culture die jarenlang in het park leefden. Vlakbij Fruita Schoolhouse kun je deze al bewonderen. De rotstekeningen verbeelden mensen met hoofddeksels en sieraden, dieren en abstracte figuren.\r\n\r\n<strong>Mormoonse overblijfselen</strong>\r\nBij het plaatsje Fruita vind je ook de overblijfselen van de Mormonen die in deze streek woonden. Ze waren een van de weinige die konden overleven in dit gebied. Toen\u00a0Capitol Reef in 1937 uitgeroepen werd tot een nationaal monument en in 1971 tot een nationaal park, werden de bewoners uitgekocht. In Fruita vind je nog een school, een schuur, enkele huizen en boomgaarden die bewaard zijn gebleven.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Hoogtepunten in Capitol Reef National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het letterlijke hoogtepunten is natuurlijk de enorme rotsformatie Waterpocket Fold die een groot deel van het park inneemt. Begin je bezoek aan Capitol Reef NP in Fruita en bekijk hier de Mormoonse overblijfselen en de petrogliefen van de Fremont Cultuur. Aan Highway 24 kun je vervolgens Grand Wash, Capitol Gorge en Goosenecks Overlook bekijken. Het ruige Cathedral Valley in het noorden is een van de plekken die je kunt bezoeken vanwege de enorme monolieten uittorenen. Via Highway 12 in het zuiden van Capitol Reef kun je het zuidelijke deel verkennen. Hier ligt het Grand Staircase-Escalante National Monument op de grens met <a href=\"https://www.heyusa.com/nl/glen-canyon-recreation-area/\" target=\"_blank\" rel=\"noopener\">Glen Canyon National Recreation Area</a>.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten in het Capitol Reef National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Overnachten in Capitol Reef NP kan alleen op campings. <a href=\"https://www.recreation.gov/camping/campgrounds/272245\" target=\"_blank\" rel=\"noopener\">Fruita Campground</a> heeft 71 plekken om je tent op te zetten. Deze camping wordt ook wel gezien als een oase in de woestijn, met een stuk grasveld omringd door rode rotsen. Overnachten kan tussen maart en eind oktober. Voor een plekje betaal je tussen de $20-$25 en zijn eigenlijk allemaal bezet in deze maanden. Er zijn nog een paar alternatieven in de omgeving, maar die zijn moeilijker te bereiken of heb je een four wheel drive voor nodig.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reisperiode Capitol Reef National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In de zomermaanden kan het in Capitol Reef warm worden, temperaturen van 40 graden zijn niet ongewoon. Ga je in deze periode Capitol Reef verkennen? Denk dan aan beschermende kleding, water en proviand (overigens ook niet in het park te koop) en duik wanneer mogelijk de schaduw in. Toch kun je in het park alle seizoenen tegenkomen en behoort een stortbui in de zomer ook tot de mogelijkheden. De meeste regen valt ook in dit seizoen en kan eventuele 'flash floods' veroorzaken. Check dus altijd de weersvoorspellingen als je richting Capitol Reef NP rijdt. In het voor- en najaar liggen de temperaturen tussen de 20-25 graden. In de winter is er kans op sneeuw en kan het er vriezen.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Oude school in Fruita\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"Overblijfselen van de Mormonen die in het gebied woonden\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"10038\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelingen &amp; trails\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]De Fruita Area is het meest geschikt voor het maken van dagwandelingen. In de buurt van Highway 24 en de Scenic Drive in het park kun je kiezen uit 15 verschillende dagwandelingen. Dat zijn gemakkelijke wandelingen van een paar kilometer of wat meer uitdagende wandelingen waar je meer moet klimmen. Je vindt ze vanaf 0.8 kilometer tot 16 kilometer en kunt de markeringen volgen.[/vc_column_text][ultimate_heading main_heading=\"Hickman Bridge\" heading_tag=\"h3\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]Een van de makkelijkste en populairste wandelingen is de Hickman Bridge Trail. De ronde is ongeveer 3 kilometer en brengt je langs ru\u00efnes van Fremont gebouwen, natuurlijke bruggen en prachtige vergezichten over canyons. Je kunt deze hike maken vanaf Highway 24 en hoeft maar een klein stukje te rijden vanaf het bezoekerscentrum.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]24/7 en 365 dagen geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: voor- en najaar[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]7 daagse pas met auto of camper: $20[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-ticket\" content_font_size=\"desktop:16px;\"]$10 per persoon voor 7 dagen[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-location-arrow\" content_font_size=\"desktop:16px;\"]15 dagwandelingen[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Hackman Bridge\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"E\u00e9n van de 15 dagwandelingen in Capitol Reef\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"10039\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Meer nationale parken\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:4738,4714,4689,4792\"][/vc_column][/vc_row]","post_title":"Capitol Reef National Park","post_link":"https://www.heyusa.com/nl/capitol-reef-national-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Capitol Reef National Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/11/capitol-reef-national-park-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capitol Reef National Park","post_tags":"Utah","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_lock%":"1637915459:2","%_edit_last%":"1","%_thumbnail_id%":"10037","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Capitol Reef National Park","%_yoast_wpseo_metadesc%":"Het Capitol Reef National Park wordt helaas vaak onterecht overgeslagen in Utah. Alle tips voor een bezoek aan Capitol Reef National Park.","%_yoast_wpseo_linkdex%":"79","%_wpgmp_location_address%":"Utah, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Utah","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.0877312","%_wpgmp_metabox_longitude%":"-111.1354983","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_primary_category%":"162","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1677015157","taxonomy=category":"Capitol Reef National Park","taxonomy=post_tag":"Utah","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png"},"id":10033,"infowindow_disable":false},{"source":"post","title":"Channel Islands National Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Channel Islands National Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/11/channel-islands-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Channel Islands National Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Ventura, Californi\u00eb 93001, Verenigde Staten","location":{"lat":"34.0069361","city":"Ventura","state":"Californi\u00eb","country":"Verenigde Staten","lng":"-119.778533","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/channel-islands-national-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Channel Islands National Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een relatief onbekend en weinig bezocht nationaal park vind je voor de kust van Californi\u00eb. De Channel Islands, bestaande uit 5 verschillende eilanden, zijn een van de belangrijkste parken van Amerika. Het gebied is redelijke ongerept gebleven en daardoor een paradijs voor vele vogels en in de wateren rondom zijn tal van zeedieren te vinden. Een bezoek aan de Channel Islands maak je niet zomaar, daarvoor moet je een goede voorbereiding treffen. Op de eilanden zijn namelijk geen voorzieningen te vinden. Ontdek een van de meest bijzondere nationale parken van Amerika: de Channel Islands.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]Hemelsbreed is Santa Barbara het verst met meer dan 80 kilometer van Santa Barbara[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">900 km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-paw\"]387 verschillende soorten vogels[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-leaf\"]<span class=\"LrzXr kno-fv\">790 verschillende soorten planten</span>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Flora en Fauna op de Channel Islands\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">De Channel Islands zijn door de Verenigde Naties uitgeroepen tot internationaal bioreservaat. Zo belangrijk zijn de eilanden voor voor de kust van Amerika. In de wateren rondom de eilanden zwemmen grijze walvissen, dolfijnen, zeeleeuwen en wel 25 verschillende soorten haaien voorbij. Door de koude zeestroming die uit de noordelijke Grote Oceaan komt en in dit gebied samenkomt met het tropische water, wordt het een unieke leefomgeving voor bijvoorbeeld microscopisch plankton en de bedreigde blauwe vinvis. Op de eilanden heb je kans om diverse (bedreigde) unieke vogelsoorten te spotten. Denk aan de Californische kuifkwartel, de struikgaai of de bedreigde bruine pelikaan.</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Imposante uitzichten over de Channel Islands\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Inspiration Point Anacapa\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"9985\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Facts Channel Islands National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Hoewel er eigenlijk 8 eilanden voor de kust van Californi\u00eb liggen, behoren er maar 5 eilanden tot het Channel Islands National Park. Naast San Miguel, Santa Cruz, Santa Rosa, Santa Barbara en Anacapa (Channel Islands NP), behoren ook Santa Catalina, San Nicolas en San Clementine tot de eilandengroep. De eilanden strekken zich uit over een lengte van 260 kilometer met San Miguel als meest noordelijke eiland en San Clemente in het zuiden.\r\n\r\n<strong>Inwoners</strong>\r\n\r\nOp de eilanden die tot de Channel Islands National Park behoren, wonen bijna geen mensen (hooguit 2/3 inwoners). De overige eilanden hebben tussen de 200 inwoners op San Nicholas en meer dan 3500 inwoners op San Catalina.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Hoogtepunten op de Channel Islands\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De eilanden van de Channel Islands zijn redelijk ge\u00efsoleerd in de zin van faciliteiten. Een bezoek aan een van de eilanden vergt enige voorbereiding. Je dient namelijk je eigen drinkwater en eten mee te nemen voor de lengte van je trip. Onderweg kun je niets kopen. Het grootste eiland Santa Cruz is het makkelijkst te bezoeken vanuit Santa Barbara. Kamperen kan op Santa Cruz voor een echt onvergetelijk avontuur, maar ook tijdens een dagtrip krijg je al een goede indruk van het eiland. Ook Santa Rosa biedt voldoende mogelijkheden tot wandelen en eventueel kamperen.\r\n\r\n<strong>Overige eilanden</strong>\r\n\r\nHoewel de andere eilanden zijn kleiner zijn, kun je ook deze bezoeken en ontdekken. Soms moet je onder begeleiding van een gids op pad, soms mag je de eilanden zelf lopend verkennen. Een auto rijdt er niet.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten op de Channel Islands\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Om te overnachten op de eilanden, lees kamperen, moet je alles zelf meenemen en de reserveringen op tijd maken. Denk hierbij niet alleen aan de reservering voor de campground, maar ook voor de boot die je met alle spullen moet brengen. Op Santa Cruz vind je een 30-tal plekken om te kamperen, Santa Rosa 15, Anacapa 7, Santa Barbara 10 en op San Miguel 9. Een beperkt aantal plekken om te overnachten. Je kunt het gehele jaar overnachten op de eilanden, vaak dien je wel minimaal 3 nachten te blijven. Voor ongeveer $15 per nacht kun je je tent opzetten. Faciliteiten zijn er niet aanwezig, even douchen, naar de toilet of je fles met water vullen is niet mogelijk. Tips voor wat je precies mee kunt nemen lees je op de <a href=\"https://www.nps.gov/chis/planyourvisit/camping.htm\" target=\"_blank\" rel=\"noopener\">offici\u00eble site</a>. Reserveringen kunnen gemaakt worden vanaf 6-5 maanden van te voren.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reisperiode voor de Channel Islands\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Je kunt het hele jaar door de Channel Islands bezoeken, alleen op Thankgiving en 1e Kerstdag is er geen mogelijkheid tot een bezoek. De (beperkt aantal) boten varen tussen 8.30 - 17.00 uur. Het weer is in de zomermaanden warm en heel droog. De temperatuur ligt in deze periode tussen de 13-27 graden, in de winter tussen 7-18 graden.\r\n\r\nHoewel de eilanden voor de kust liggen van het zonnige Californi\u00eb, zijn ze onder invloed van de oceaan waardoor de condities per dag kunnen verschillen. Een bezoek aan de eilanden kan dus altijd en is in ieder seizoen ook prachtig om te doen, houdt rekening met eventuele mist, een wilde zee en 'sea spray'.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Hiken op de Channel Islands\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"Ultiem genieten van de rust en weidsheid\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"9988\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Channel Islands National Park\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][ultimate_heading main_heading=\"De vijf verschillende eilanden\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:30px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_line_height=\"desktop:35px;\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_single_image image=\"9984\" img_size=\"full\"][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"1.\" heading_tag=\"div\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:95px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:100px;\"][/ultimate_heading][ultimate_heading main_heading=\"Santa Barbara\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Om bij Santa Barbara te komen, moet je een tijdje op de boot zitten. Het eiland ligt het het meest zuidelijke van de 5. Verkennen kan via een netwerk van wandelpaden. Daarnaast heb je grote kans om hier zeeleeuwen en zeehonden te zien die in de baai rondom het eiland voorkomen. Het is ook de plek voor vogelliefhebbers, want het spotten van een Amerikaanse torenvalk, strandleeuwerik, een kerkuil of een bruine pelikaan gebeurt je niet iedere dag.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"2.\" heading_tag=\"div\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:95px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:100px;\"][/ultimate_heading][ultimate_heading main_heading=\"Anacapa\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Anacapa bestaat uit 3 kleine eilanden waarvan de meeste oostelijke (East Anacapa) het vaakst wordt bezocht. West Anacapa is niet toegankelijk voor bezoekers omdat de bedreigde bruine pelikaan dit eiland heeft uitgezocht als broedplaats. In de baaien rondom kun je perfect snorkelen en duiken door de wonderlijke onderwaterwereld. Tal van zeedieren kun je spotten tijdens je snorkel- en duikavonturen, zelfs zeehonden en walvissen. Geen zin om een duik te nemen? Wandel dan rond op het eiland.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"3.\" heading_tag=\"div\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:95px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:100px;\"][/ultimate_heading][ultimate_heading main_heading=\"Santa Cruz\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Het grootste eiland en het eiland dat je het makkelijkst kunt bezoeken is Santa Cruz. De oostkant van het eiland wordt beheerd door de National Park Service, het andere deel behoort tot The Nature Conservancy en dien je vergunningen voor te regelen. Je snapt dan wel dat het oostelijke deel het meest bezocht wordt. In het visitor center, die zich bevindt in een oude boerderij, is een tentoonstelling te zien over de Chumash Indianen en het onderwaterleven rondom de eilanden. Het oude gebouw ernaast is inmiddels de slaapplek geworden voor de Townsend Vleermuis.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"4.\" heading_tag=\"div\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:95px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:100px;\"][/ultimate_heading][ultimate_heading main_heading=\"Santa Rosa\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Het op een na grootste eiland van het nationale park is Santa Rosa. Je kunt hier meerdere dagen doorbrengen indien je het ultieme avontuur aan durft te gaan. Santa Rosa is een bergachtig eiland waar je in de lente prachtige bloemen in bloei ziet. Het eiland leent zich perfect voor het maken van een wandeling op een van de trails die er te vinden zijn. En heb je nog tijd over, beklim dan Soledad Peak.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"5.\" heading_tag=\"div\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:95px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:100px;\"][/ultimate_heading][ultimate_heading main_heading=\"San Miguel\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">San Miguel is het moeilijkst bereikbare eiland van het park. De betoverende plek wordt omringd door hoge golven die op de kust van San Miguel gesmeten worden. Het is de plek waar je 6 (!) verschillende soorten zeehonden en zeeleeuwen kunt zien. De kliffen van Point Bennet zijn hiervoor de aangewezen plek. Overigens moet je hiervoor wel een redelijke wandeling maken van ruim 20 kilometer (en onder begeleiding) Een andere plek die je niet mag missen is Cuyler's Harbor die je wel op eigen houtje kunt ontdekken.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Zeehonden en zeeleeuwen spotten\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"Spot tot wel 6 (!) verschillende soorten\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"9990\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Hoe kom je op de Channel Islands?\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]Je kunt de Channel Islands het beste bereiken per boot (andere optie is een klein vliegtuigje). <a href=\"http://islandpackers.com/\" target=\"_blank\" rel=\"noopener\">Island Packers</a> heeft als enige de mogelijkheid om je per boot naar een van de eilanden te brengen. Vertrekken doe je vanuit de bezoekerscentra van Ventura en Santa Barbara.\r\n<ul>\r\n \t<li>Anacapa: 3-7 dagen per week | vaartijd vanaf Ventura &amp; Oxnard Harbors 1 uur | enigszins klimmen van de boot af</li>\r\n \t<li>Santa Cruz: 5-7 dagen per week | vaartijd vanaf Ventura 1 uur</li>\r\n \t<li>Santa Rosa: april tot begin november | 2-4 dagen per week | vaartijd vanaf Ventura 3 uur</li>\r\n \t<li>San Miguel: april tot begin november | 4-8 dagen per maand | vaartijd vanaf Ventura 4 uur</li>\r\n \t<li>Santa Barbara: lente tot herfst | 2-4 dagen per maand | vaartijd vanaf Ventura 3 uur</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]363 dagen geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: gehele jaar door[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]Gratis - je betaald voor de boottocht[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-location-arrow\" content_font_size=\"desktop:16px;\"]Diverse wandelpaden[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Mist op de Channel Islands\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"Bereid je trip naar de Channel Islands goed voor!\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"9986\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Meer nationale parken\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:4738,4714,4689,4792\"][/vc_column][/vc_row]","post_title":"Channel Islands National Park","post_link":"https://www.heyusa.com/nl/channel-islands-national-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Channel Islands National Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/11/channel-islands-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Channel Island National Park","post_tags":"Californi\u00eb","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1703755255:2","%_edit_last%":"1","%_thumbnail_id%":"9987","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Channel Islands National Park","%_yoast_wpseo_metadesc%":"De Channels Islands voor de kust van Californi\u00eb, onontdekt en weinig bezocht. Alles wat je moet weten voor je bezoek aan de Channels Islands","%_yoast_wpseo_linkdex%":"68","%_wpgmp_location_address%":"Ventura, Californi\u00eb 93001, Verenigde Staten","%_wpgmp_location_city%":"Ventura","%_wpgmp_location_state%":"Californi\u00eb","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"34.0069361","%_wpgmp_metabox_longitude%":"-119.778533","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"8","%_yoast_wpseo_primary_category%":"161","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1677015161","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Channel Island National Park","taxonomy=post_tag":"Californi\u00eb","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png"},"id":9980,"infowindow_disable":false},{"source":"post","title":"Horseshoe Bend in Arizona","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Horseshoe Bend\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/11/horseshoe-bend-header-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Horseshoe Bend in Arizona</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1001 Page Parkway, Page, AZ 86040, Verenigde Staten","location":{"lat":"36.8791598","city":"Page","state":"Arizona","country":"Verenigde Staten","lng":"-111.5104235","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/horseshoe-bend/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Horseshoe Bend in Arizona\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een van de mooiste bezienswaardigheden in Arizona is misschien wel Horseshoe Bend. De bekendste hoefijzer bocht in Amerika is inmiddels reuze populair. Je vindt de Horseshoe Bend in het recreatiegebied Glen Canyon aan US Highway 89. Alle tips voor een bezoek aan Horseshoe Bend in Arizona.[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]$30 voor een auto[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]$15 voor individuele toegang[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-location-arrow\"]Aan Highway 89[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612950540814{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Het ontstaan van Horseshoe Bend\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Dat de Horseshoe Bend een indrukwekkende vorm heeft hoeven we je niet te vertellen. De hoefijzer van Amerika wordt het ook wel genoemd. De naam is zelfs zo populair, dat vergelijkbare plekken op de wereld ook wel de Horseshoe Bend van het land genoemd worden. Om te kijken naar het ontstaan van de Horseshoe Bend moeten we 200 jaar terug in de tijd toen een gigantische massa zandduinen het landschap bedekte. In de loop van de jaren versteende dit landschap en ontstonden er verschillende lagen. De <a href=\"https://www.nps.gov/glca/planyourvisit/horseshoe-bend.htm\" target=\"_blank\" rel=\"noopener\">Horseshoe Bend</a> ligt aan de Colorado Rivier op het Colorado Plateau. Toen de rivier een weg door de rotsen zocht, werd de weg van de minste weerstand gevonden en werd een bocht van 270 graden gecre\u00eberd.</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Zonsondergang bij Horseshoe Bend\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"E\u00e9n van de mooiste momenten om te fotograferen\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"9829\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"De beste periode om de Horseshoe Bend te fotograferen\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Eigenlijk kun je op ieder moment toffe foto's maken bij de Horseshoe Bend, maar wil je d\u00e9 perfecte foto? Kom dan rond zonsondergang of direct na het middaguur. Rond zonsondergang heb je het gouden uurtje waardoor het landschap prachtige kleuren heeft. Na het middaguur staat de zon op de beste plek, je hebt dan geen last van schaduwen. Om de Horseshoe Bend goed te fotograferen, is een groothoeklens handig om mee te nemen.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Horseshoe Bend Trail\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Bij het uitkijkpunt heb je het beste uitzicht op de Horseshoe Bend. Hiervoor dien je een kleine wandeling te maken via de Horseshoe Bend Trail. Deze trail is ongeveer 1,5 kilometer en gaat via een breed wandelpad dat bestaat uit hard grind, een relatief makkelijke wandeling.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"In de omgeving van de Horseshoe Bend\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In het <a href=\"https://www.heyusa.com/nl/glen-canyon-recreation-area/\" target=\"_blank\" rel=\"noopener\">Glen Canyon Recreation Area</a> vind je naast Horseshoe Bend nog diverse andere hoogtepunten om te bezoeken. Lake Powell en de Glen Canyon Dam zijn ook de moeite waard. Iets verder weg liggen Antelope Canyon, <a href=\"https://www.heyusa.com/nl/grand-canyon-national-park/\" target=\"_blank\" rel=\"noopener\">Grand Canyon</a> en <a href=\"https://www.heyusa.com/nl/navajo-tribal-park/monument-valley/\" target=\"_blank\" rel=\"noopener\">Monument Valley</a>. Een kleine roadtrip langs al deze natuurlijke hoogtepunten van Arizona is zeer de moeite waard.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"On the edge\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_custom_heading text=\"Vanwege de vele ongelukken staat er tegenwoordig een hek\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:3\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"9831\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"In de buurt van Horseshoe Bend\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:6209,4195,3208,3014\"][/vc_column][/vc_row]","post_title":"Horseshoe Bend in Arizona","post_link":"https://www.heyusa.com/nl/horseshoe-bend/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Horseshoe Bend\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/11/horseshoe-bend-header-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Tribal Parken","post_tags":"Arizona, Natuur, Navajo, Tribal Park","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1612950540814{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"2","%_edit_lock%":"1681201980:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"32","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"9830","%_yoast_wpseo_focuskw%":"Horseshoe Bend in Arizona","%_yoast_wpseo_metadesc%":"Een van de mooiste bezienswaardigheden in Arizona is misschien wel Horseshoe Bend. Tips voor Horsehoe Bend in Arizona.","%_yoast_wpseo_linkdex%":"79","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Horseshoe bend \"]","%_wpgmp_location_address%":"1001 Page Parkway, Page, AZ 86040, Verenigde Staten","%_wpgmp_location_city%":"Page","%_wpgmp_location_state%":"Arizona","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"36.8791598","%_wpgmp_metabox_longitude%":"-111.5104235","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_primary_category%":"39","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1681201975","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Tribal Parken","taxonomy=post_tag":"Arizona, Natuur, Navajo, Tribal Park","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/parken.png"},"id":9826,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/parken.png","name":"Nationale Parken","id":"7","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Hiken naar Havasu Falls in Arizona","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Havasu Falls\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/09/Havasu-Falls-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Hiken naar Havasu Falls in Arizona</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Havasu Falls, Arizona 86435, Verenigde Staten","location":{"lat":"36.25520910000001","state":"Arizona","country":"Verenigde Staten","lng":"-112.6979449","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/hike-havasu-falls-arizona/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Hiken naar Havasu Falls in Arizona\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]E\u00e9n van de dingen die je op je bucketlist kunt zetten is de hike naar de Havasu Falls in Arizona. Net buiten het Grand Canyon National Park vind je het Havasupai Indian Reservation (wel onderdeel van het Grand Canyon National Park) waarin de Havasu Falls zich bevinden. Enorm prachtige watervallen vernoemd naar het oorspronkelijke grondgebied Havasu Baaja, wat mensen van de blauwgroene wateren betekent. Geen rare naam gezien de blauwgroene wateren bij de Havasu Falls. Ondanks dat het geen toegankelijke wandeling is, is het er wel \u00e9\u00e9n die regelrecht op je bucketlist kan. Je bent dan \u00e9\u00e9n van de weinigen die de Havasu Falls op de bodem van de Grand Canyon gezien heeft.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]340 van Las Vegas[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">30 meter hoogte</span>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Havasu Falls\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">De Havasu Falls behoren tot het Havasupai Indian Reservation en zijn de bekendste watervallen in het gebied. De waterval bestaat uit een hoofdbaan die over een verticale klif 30 meter naar beneden valt. Daar valt het water in een grote poel. Rondom vind je diverse natuurlijke poelen die gecre\u00eberd zijn door mineralisatie. Je kunt achter de waterval zwemmen en de kleine schuilplaats nog bezoeken. Tijdens je verblijf kun je je vermaken met zwemmen en eventueel nog andere hikes naar andere watervallen als de Mooney Falls en de Beaver Falls. De echte die-hards kunnen tot aan de Colorado rivier wandelen.</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"De Havasu Falls\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Regelrecht op je bucketlist\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"8748\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Wat heb je nog voor de Havasu Falls hike?\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Hiken naar Havasu Falls gaat niet zomaar. Je hebt een aantal dingen nodig voordat je \u00fcberhaupt mag starten met wandelen.\r\nTwee dingen zijn noodzakelijk:\r\n<ul>\r\n \t<li>Permit om te wandelen</li>\r\n \t<li>Reservering overnachtingen bij de campground of the lodge</li>\r\n</ul>\r\nDe wandeling naar beneden maak je lopend. Je dient dus alles mee te nemen voor je verblijf. Denk daarbij aan de volgende dingen wanneer bovenstaande gelukt is:\r\n<ul>\r\n \t<li>Goede wandelschoenen</li>\r\n \t<li>Waterschoenen</li>\r\n \t<li>Zonnebrand</li>\r\n \t<li>Pet</li>\r\n \t<li>1e hulp spullen</li>\r\n \t<li>Snack</li>\r\n \t<li>Water - heeel veel water (in ieder geval zo'n 4 liter)</li>\r\n \t<li>Badkleding</li>\r\n \t<li>Handdoek</li>\r\n \t<li>Camera</li>\r\n \t<li>Eten - ook voor in de lodge</li>\r\n \t<li>Kampeerspullen - mocht je gaan kamperen</li>\r\n \t<li>Spullen om te overnachten</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Een paar belangrijke dingen om in gedachten te houden\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Hoewel het klinkt alsof de hike niet toegankelijk is voor velen, is dat niet per se het geval. Je dient je grondig voor te bereiden en ruim op tijd te reserveren. Hierdoor kom je wel bij een plek waar niet veel mensen komen en waar je niet overspoeld wordt met toeristen. Een paar belangrijke dingen om in gedachten te houden zijn:\r\n<ul>\r\n \t<li>Je auto en bagage mag bij aankomst onderzocht worden; drugs, wapens, alcohol en drones zijn verboden</li>\r\n \t<li>Er is geen wifi beneden, je hebt \u00fcberhaupt geen bereik in de canyon</li>\r\n \t<li>Er is geen emergency assistance onderweg en beneden, het is lastig voor hulpverleners om de plek te bereiken</li>\r\n</ul>\r\nWanneer je beneden in de canyon aankomt mag je inchecken bij de Tourist Check-in Office. Je dient je reservering te laten zien van de camping en het nummerbord van je voertuig door te geven. De lodge bevindt zich trouwens in Supai Village, vanaf daar is het nog 4 kilometer naar de watervallen.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten bij de Havasu Falls\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Je hebt een tweetal mogelijkheden om te overnachten wanneer je naar de Havasu Falls wandelt. De eerste is de <a href=\"https://www.havasupaireservations.com/\" target=\"_blank\" rel=\"noopener\">campground</a> waar je een reservering voor moet hebben (op de bonnefooi en voor een dagtrip is absoluut niet mogelijk). Voor de camping kun je alleen online reserveren en je moet er dus op tijd bij zijn. Je verblijf is minimaal 3 nachten - 4 dagen en denk hierbij aan bedragen tussen de $100-$125 per nacht, per persoon. De andere optie is de <a href=\"https://theofficialhavasupaitribe.com/Havasupai-Lodge/havasupai-lodge.html\" target=\"_blank\" rel=\"noopener\">Lodge</a>. Een vierpersoons lodge kost je rond de $400 per nacht per persoon. Hierbij komt nog een $110 entree fee overheen, hier zit je permit overigens bij in. Goedkoop is overnachten niet, maar je krijgt er wel een ultieme ervaring voor terug.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reistijd voor de wandeling naar de Havasu Falls\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Je kunt de Havasu Falls alleen tussen februari en november bezoeken. Daarna is het niet mogelijk om de afdaling te maken. Tussen juni en augustus is het gesloten omdat er kans is op overstromingen en kunnen de temperaturen hoger worden dan 46 graden.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Havasu Falls Campground\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"Prachtig wakker worden\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"8746\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"De wandeling naar de Havasu Falls\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]En nu waar het allemaal om draait. Je hebt alles geregeld en mag starten met de wandeling naar de Havasu Falls! Starten doe je bij Hualapai Hilltop. De wandeling zelf wordt gezien als moeilijk en dat blijkt direct in het eerst gedeelte al. Er dienen direct zo'n 500 hoogtemeters overbrugd te worden. Daarna wordt de trail iets vlakker richting Supai. Vanaf daar is het nog zo'n 4 kilometer tot de campground. Onderweg kom je 3 watervallen tegen; de Fifty Foot, Lower Navajo en Havasu Falls. De gehele wandeling, 16 kilometer in totaal, kost je zo'n 4 uur. De temperaturen in deze maanden zijn vaak al hoog, dus dat maakt het wandelen extra lastig. Zorg daarom dat als je de mogelijkheid hebt, je de schaduw pakt.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]Februari - November (juni-augustus weer gesloten)[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode:\u00a0 februari, maart, oktober &amp; november[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]Hangt af van je overnachting[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-ticket\" content_font_size=\"desktop:16px;\"]<a href=\"https://www.havasupaireservations.com/public/login\" target=\"_blank\" rel=\"noopener\">Permit aanvragen</a>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Hiken rond de Havasu Falls\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"Wat een uitzichten onderweg!\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"8747\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Tips voor in de omgeving\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:4460,3208,1273,4663\"][/vc_column][/vc_row]","post_title":"Hiken naar Havasu Falls in Arizona","post_link":"https://www.heyusa.com/nl/hike-havasu-falls-arizona/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Havasu Falls\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/09/Havasu-Falls-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Avontuur","post_tags":"Arizona","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_lock%":"1677014632:1","%_edit_last%":"1","%_thumbnail_id%":"8749","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Hiken naar Havasu Falls in Arizona","%_yoast_wpseo_metadesc%":"Hiken naar Havasu Falls in Arizona. Alles wat je moet weten over deze bucketlist ervaring in de buurt van de Grand Canyon.","%_yoast_wpseo_linkdex%":"78","%_wpgmp_location_address%":"Havasu Falls, Arizona 86435, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Arizona","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"36.25520910000001","%_wpgmp_metabox_longitude%":"-112.6979449","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%_yoast_wpseo_primary_category%":"67","%_yoast_wpseo_title%":"Hiken naar Havasu Falls in Arizona %%page%% %%sep%% %%sitename%%","%_last_editor_used_jetpack%":"classic-editor","%_yoast_indexnow_last_ping%":"1677015156","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Avontuur","taxonomy=post_tag":"Arizona","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png"},"id":8742,"infowindow_disable":false},{"source":"post","title":"Big Bend National Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Big Bend National Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/09/Big-Bend-NP-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Big Bend National Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Big Bend National Park, TX, Verenigde Staten","location":{"lat":"29.2498194","city":"Big Bend National Park","state":"Texas","country":"Verenigde Staten","lng":"-103.2501636","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/big-bend-national-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Big Bend National Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Big Bend, de grote bocht. E\u00e9n van de twee nationale parken in Texas is het Big Bend National Park. Big Bend National Park ligt in een enorme bocht in de Rio Grande. Het park wordt nog altijd gezien als <em>despoblado</em>, een leeg land en dat komt wel overeen met het beeld dat we hebben van Texas. En net als Texas is het nationale park ook groot. In tegenstelling tot wat je misschien verwacht is het Big Bend National Park een enorm fauna rijk gebied. Zo vind je er bijvoorbeeld meer dan 1200 verschillende planten. Hoewel het \u00e9\u00e9n van de minst bezochte parken in Amerika is, is het onherbergzame Big Bend een aanrader om te bezoeken wanneer je in Texas bent. Alle informatie over Big Bend National Park.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]600 kilometer van San Antonio[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">3242 km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-paw\"]75 verschillende soorten zoogdieren[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-leaf\"]<span class=\"LrzXr kno-fv\">1200 verschillende soorten planten</span>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"De dinosaurussen van Big Bend National Park\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Dinosaurussen in het echt? Het kan deels in Big Bend National Park. Hoewel echt, bij het Panther Junction Visitor Center vind je een replica van beenderen van een enorme dinosaurus die ooit in het park leefde. De Pterosaurus was een vliegende dinosaurus die ooit voorkwam in het park. In de jaren '70 werden botten van met dan 5 meter lang gevonden in het park. De spanwijdte van een Pterosaurus kon wel meer dan 10 meter worden waardoor het \u00e9\u00e9n van de grootste vliegende wezens ooit\u00a0 op aarde was. Ontdek bij het visitor center hoe groot deze dinosaurus eigenlijk was.</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"De Rio Grande\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Big Bend ligt in een enorme bocht van de Rio Grande\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"8711\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Facts Big Bend National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Lange tijd was het Big Bend National Park een plek die je zoveel mogelijk vermeed. Het gebied was wetteloos waardoor er dagelijks vele overvallen plaatsvonden. Na een periode van goudzoekers, die het gebied al snel weer verlieten, kocht in 1944 de regering het land op. Een gebied van 285.000 hectare werd uitgeroepen tot nationaal park, tegenwoordig is het gebied nog groter. De beroemde Rio Grande stroomt dwars door het park en zorgt voor canyons van 450 meter hoog. Hoewel het landschap van het Big Bend National Park enorm desolaat is, is er genoeg flora en fauna dat er voorkomt. Het is ook de plek voor vogelliefhebbers omdat je er zoveel verschillende soorten kunt spotten! Je vindt er ongeveer de helft van alle Amerikaanse vogelsoorten.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Hoogtepunten in Big Bend National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het meest bekende en populaire deel van Big Bend National Park is Chisos Basin. Hier vind je dan ook de meeste toeristen. Vanaf hier heb je een goede mogelijkheid om het park te ontdekken. Ben je wat korter in het park? Dan zijn er drie routes die je kunt rijden om een goede indruk te krijgen. De Maverick Drive (35 km), Ross Maxwell Scenic Drive (48km), Rio Grande Village Drive (32km). Vanaf deze routes heb je de mogelijkheid om andere hoogtepunten te ontdekken in het park.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten in het Big Bend National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In het Big Bend National Park heb je de mogelijkheid om in de Chisos Mountain Lodge te overnachten. Natuurlijk ben je goedkoper uit buiten het park, maar bij de Chisos Mountain Lodge heb je de ultieme Big Bend ervaring. Je kunt makkelijker de trails op en hoeft niet nog naar een accommodatie buiten het park te rijden na afloop. Wanneer je een RV hebt of wilt kamperen, heb je drie opties. De Chisos Basin, De Cottonwood en de Rio Grande zijn de campgrounds in het park. De laatstgenoemde is de grootste met 100 plekken.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reisperiode Big Bend National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Big Bend National Park kan het hele jaar door bezocht worden. Toch kan het weer kan enorm divers zijn in de regio. De maanden mei en juni zijn het warmst met hoge temperaturen van wel 40 graden. De lente is de beste periode met aangename temperaturen om het park te verkennen. Van juli tot en met oktober heb je kan op een regenbui in de middag. En in de winter kan de temperatuur tussen de 0-18 graden liggen. Het weer in Big Bend National Park kan ineens omslaan, dus houd daar rekening mee wanneer je gaat wandelen.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Despoblado\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"Het lege land\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"8712\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelingen &amp; trails\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]Hoewel een groot deel van het park ongerepte wildernis is, heb je redelijk wat mogelijkheden om te wandelen. Er zijn een aantal day hikes die je kunt doen door het desolate landschap van Big Bend National Park. In totaal is er meer dan 240 kilometer aan wandelpaden te vinden in het park.[/vc_column_text][ultimate_heading main_heading=\"Lost Mine Trail\" heading_tag=\"h3\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]Een van de leukste wandelingen om te doen in Big Bend National Park is de Lost Mine Trail. Het is een wandeling van ongeveer 6,5 kilometer, maar \u00e9\u00e9n waarbij je flink moet klimmen. Eenmaal boven is de klim de moeite waard met prachtige uitzichten over de Chisos Mountains.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]24/7 en 365 dagen geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: lente[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]7 daagse pas met auto of camper: $30[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-ticket\" content_font_size=\"desktop:16px;\"]$15 per persoon voor 1-7 dagen[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-location-arrow\" content_font_size=\"desktop:16px;\"]240 kilometer aan wandelpaden[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Trail in Big Bend National Park\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"150 mijl aan wandelpaden\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"8713\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Meer nationale parken\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:4738,4714,4689,4792\"][/vc_column][/vc_row]","post_title":"Big Bend National Park","post_link":"https://www.heyusa.com/nl/big-bend-national-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Big Bend National Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/09/Big-Bend-NP-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Big Bend National Park","post_tags":"Texas","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_lock%":"1637907284:2","%_edit_last%":"1","%_thumbnail_id%":"8714","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Big Bend National Park","%_yoast_wpseo_metadesc%":"Het onherbergzame Big Bend National Park in Texas is een van de nationale parken van de staat. Alle tips voor een bezoek aan Big Bend National Park.","%_yoast_wpseo_linkdex%":"59","%_wpgmp_location_address%":"Big Bend National Park, TX, Verenigde Staten","%_wpgmp_location_city%":"Big Bend National Park","%_wpgmp_location_state%":"Texas","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"29.2498194","%_wpgmp_metabox_longitude%":"-103.2501636","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_primary_category%":"152","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1677015160","taxonomy=category":"Big Bend National Park","taxonomy=post_tag":"Texas","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png"},"id":8706,"infowindow_disable":false},{"source":"post","title":"Mount Rushmore in South Dakota","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Mount Rushmore in South Dakota gefotografeerd vanuit het bos\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/08/mount-rushmore-forest-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Mount Rushmore in South Dakota</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"13000 SD-244, Keystone, SD 57751, Verenigde Staten","location":{"lat":"43.87910249999999","city":"Mount Rushmore UT","state":"South Dakota","country":"Verenigde Staten","lng":"-103.4590667","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/mount-rushmore-south-dakota/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"25px\"][ultimate_heading main_heading=\"Mount Rushmore in South Dakota\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][ultimate_heading main_heading=\"Mount Rushmore National Memorial\" heading_tag=\"h3\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_font_size=\"desktop:30px;\" main_heading_line_height=\"desktop:35px;\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_column_text]<strong>Een bezoek aan de uitgehakte <a href=\"https://www.heyusa.com/nl/presidenten-amerika/\">presidentshoofden</a> van Mount Rushmore, nabij het plaatsje Keystone in South Dakota is een van de bezienswaardigheden in de staat die je niet mag missen. De staat wordt niet voor niets 'Mount Rushmore State' genoemd. De route door de Black Hills van South Dakota is al de moeite waard en voor je het weet sta je oog in oog met de gezichten van Washington, Jefferson, Lincoln en Roosevelt. Alles over Mount Rushmore!\r\n</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"13000 SD-244 | Keystone SD\"][thb_iconlist icon=\"fas fa-dollar-sign\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Entree: Gratis | Parkeergeld $10\"][thb_iconlist icon=\"fas fa-history\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Oktober - Maart: 05.00-21.00 uur | Maart - September: 05.00-23.00 uur | 365 dagen per jaar geopend\"][vc_empty_space height=\"25px\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Het ontstaan van Mount Rushmore\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Tussen 1927 en 1941 werkte de ontwerper Gutzon Borglum met vierhonderd werklieden aan het monument. Daarbij kreeg hij ook (financi\u00eble) hulp van enkele invloedrijke politici. Borglum had een visie dat hij de hoofden van vier Amerikaanse presidenten wilde uithakken in de berg: George Washington (Amerika\u2019s eerste president), Thomas Jefferson (de president die voor de onafhankelijkheidsverklaring zorgde), Abraham Lincoln (die de slavernij afschafte en het land ondanks de burgeroorlog bijeenhield) en Theodore Roosevelt (die Amerika haar fraaie nationale parken schonk). Het monument herdenkt de geboorte, groei en ontwikkeling van de Verenigde Staten. Hoe de presidenten hun gezichten uiteindelijk kregen? Met dynamiet, drilboren en beitels.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Mount Rushmore\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Het symbool voor geboorte, groei en ontwikkeling in Amerika\" font_size=\"45\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"8150\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Bij Mount Rushmore in South Dakota\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Presidential Trail\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In een halfuurtje loop je via de Presidential Trail grotendeels onder de presidentshoofden langs en zie je ze steeds vanuit een ander perspectief. Erg fraai. Het levert mooie foto\u2019s op en fysiek is de wandeling prima vol te houden. Wie gewoon op het pad blijft, kan niet verdwalen. De tour begint en eindigt op het Grand View Terrace. Ook is er een audiotour te doen die veel informatie geeft over het nationale monument in South Dakota.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Evening Lighting Ceremony\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Om klokslag 21.00 uur in de maanden juni tot en met augustus kun je de <a href=\"https://www.nps.gov/planyourvisit/event-details.htm?id=366336D9-F0C9-28A4-A95A7743A8F4F96E\" target=\"_blank\" rel=\"noopener\">avondceremonie</a> bekijken. Vanuit het Amphitheater, een openluchttheater bij Mount Rushmore, kun je deze ceremonie bekijken. Een parkranger doet eerst een presidenti\u00eble quiz met het publiek. Ondertussen wordt het langzaam donker en zijn de presidentshoofden niet meer te zien. Totdat het tijd is voor het Amerikaanse volkslied. Iedere avond wordt dat door velen (inclusief buitenlandse toeristen) meegezongen. Op dat moment worden de hoofden langzaam verlicht. Aan het einde van het volkslied zijn de uitgehakte presidentshoofden goed te zien. Gejuich en applaus klinkt inmiddels over de bergen van de Black Hills. En hoewel zo\u2019n ceremonie nog maar eens benadrukt hoe chauvinistisch de Amerikanen soms zijn ingesteld,\u00a0 mag ook worden gezegd hoe leuk en bijzonder het is om daar eens bij te zijn geweest.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Crazy Horse Memorial\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Niet alleen de Amerikaanse presidenten zijn te zien in de bergen van South Dakota, \u00f3\u00f3k het 19e-eeuwse opperhoofd Crazy Horse, de leider van de Native-Amerikaanse Lakota stam is (deels) uitgehakt in de bergen. Aan het beeld van de Indianenleider werd in 1948 begonnen, maar is tot op heden nog altijd niet klaar. Zijn gezicht is sinds 1998 duidelijk te zien, maar wanneer de rest zichtbaar wordt is afwachten.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Crazy Horse Memorial\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Memorial voor Lakota leider Crazy Horse\" font_size=\"45\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"8149\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Foto's van Mount Rushmore:\" font_container=\"tag:div|font_size:35|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"25px\"][thb_image_slider thb_columns=\"small-12 medium-6\" lightbox=\"mfp-gallery\" thb_equal_height=\"true\" images=\"15694,15697,15698,15696,8151\"][fullwidth_row content_width=\"95%\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ook leuk om te lezen:\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][fullwidth_row][thb_postgrid columns=\"4\" source=\"post_type:post|by_id:7893,7243,6839,6793\"][/vc_column][/vc_row]","post_title":"Mount Rushmore in South Dakota","post_link":"https://www.heyusa.com/nl/mount-rushmore-south-dakota/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Mount Rushmore in South Dakota gefotografeerd vanuit het bos\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/08/mount-rushmore-forest-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden","post_tags":"South Dakota","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1681551980:1","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"16","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%_yoast_wpseo_focuskw%":"Mount Rushmore","%_yoast_wpseo_title%":"Mount Rushmore in South Dakota %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Mount Rushmore is de trekpleister van South Dakota. De hoofden van presidenten Washington, Jefferson, Lincoln en Roosevelt zijn hier uitgehakt in de rotsen.","%_yoast_wpseo_linkdex%":"81","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"13000 SD-244, Keystone, SD 57751, Verenigde Staten","%_wpgmp_location_city%":"Mount Rushmore UT","%_wpgmp_location_state%":"South Dakota","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"43.87910249999999","%_wpgmp_metabox_longitude%":"-103.4590667","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"15696","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_primary_category%":"65","%_yoast_indexnow_last_ping%":"1681551849","%_last_editor_used_jetpack%":"classic-editor","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Bezienswaardigheden","taxonomy=post_tag":"South Dakota","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":8146,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"De Niagara Falls &#8211; tips voor een bezoek aan de Niagara watervallen","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Niagara Falls\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/08/niagara-falls-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">De Niagara Falls &#8211; tips voor een bezoek aan de Niagara watervallen</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Niagara Falls, New York, Verenigde Staten","location":{"lat":"43.0962143","city":"Niagara Falls","state":"New York","country":"Verenigde Staten","lng":"-79.0377388","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/niagara-falls/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"De Niagara Falls - tips voor een bezoek aan de Niagara Watervallen\" font_container=\"tag:h2|font_size:45|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Alles wat je moet weten over de Niagara Watervallen\" font_container=\"tag:div|font_size:35|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"5px\"][vc_column_text]Niagara Falls of ook wel de Niagara Watervallen, gelegen op de grens van de Verenigde Staten en Canada. Het uitzicht vanaf de Amerikaanse kant is totaal anders dan het uitzicht vanaf de Canadese kant. Welke kant kies je om te bezoeken en wat kun je er doen? Tips voor een bezoek aan de Niagara Watervallen![/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Niagara Falls - op de grens tussen Canada en Amerika\" font_container=\"tag:h3|font_size:45|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De Niagara Falls liggen op de grens van Amerika en Canada en zijn een publiekstrekker bij een rondje in het oosten van zowel Amerika als Canada of voor een dagtrip vanuit <a href=\"https://www.heyusa.com/nl/new-york/\" target=\"_blank\" rel=\"noopener\">New York</a>. De Niagara watervallen bestaan uit drie verschillende delen: Horseshoe Falls, American Falls en Bridal Veil Falls. Het water valt niet eens enorm de diepte in, de watervallen staan vooral bekend om de enorme breedte. De Horseshoe Falls zijn zo'n 670 meter breed en daardoor geweldig om te bekijken. Je kunt zowel de Amerikaanse als Canadese kant van de Niagara watervallen bezoeken, maar welke kies je? Beide kanten hebben verschillende excursies om de watervallen van dichtbij te bekijken. Misschien is de Canadese kant stiekem mooier vanwege het totaaloverzicht op de Niagara Falls. Ga je richting de Niagara watervallen? Neem dan de tijd om beide kanten te bekijken en blijf een nachtje slapen in de buurt om de tijd optimaal te gebruiken.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"8118\" img_size=\"large\" add_caption=\"yes\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Wat te doen rondom de Niagara Watervallen?\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23c59c4d|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"13951\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Niagara Falls bezoeken- tips voor excursies aan de Amerikaanse kant\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"1.\" font_container=\"tag:div|font_size:75|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Maid of the Mist\" font_container=\"tag:h3|font_size:45|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Met de <a href=\"https://www.getyourguide.com/niagara-falls-usa-l87888/niagara-falls-usa-guided-tour-with-maid-of-the-mist-boat-t402712/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=niagarafallsmaidofmist\">Maid of the Mist</a> boek je een excursie waarbij je dicht bij de watervallen komt. Je vaart praktisch langs de watervallen. In de avond zijn er ook tochten die je kunt boeken. Erg leuk, want de watervallen worden dan verlicht in allerlei kleuren. Ga je in de herfst? Dan zijn er in de weekenden ook vuurwerkshows waarvoor de boot speciaal blijft liggen, zodat je het spektakel goed kunt bekijken. Doe wel een poncho of regenjas aan want je wordt behoorlijk nat.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"8117\" img_size=\"large\" add_caption=\"yes\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"8114\" img_size=\"large\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"2.\" font_container=\"tag:div|font_size:75|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Cave of the winds\" font_container=\"tag:h3|font_size:45|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]The Cave of the Wind is officieel de naam van een natuurlijk grot die je vindt achter de Bridal Veil Falls. Het werd ontdekt in 1834 en is zo'n 130 meter hoog en 9 meter diep. Tegenwoordig is het de naam van een <a href=\"https://www.getyourguide.com/niagara-falls-usa-l87888/niagara-falls-cave-of-the-winds-express-pass-and-tour-t404798/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=niagarafallscaveofthewind\" target=\"_blank\" rel=\"noopener\">attractie</a> die je kunt bezoeken op Goat Island. Via loopbruggen kun je de huidige Cave of the Wind ontdekken. Je daalt tot het niveau van de Niagara rivier aan de voet van de American Falls en kunt vanaf daar lopen naar de voet van de Bridal Veil Falls. Dat de excursie zo heet is natuurlijk niet voor niets, de wind kan onder de watervallen snelheiden bereiken tot 110 kilometer per uur. In de herfst en winter is deze excursie niet te boeken omdat de platformen hersteld worden en het in die periodes gevaarlijk kan zijn.[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"3.\" font_container=\"tag:div|font_size:75|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Observation Tower\" font_container=\"tag:h3|font_size:45|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Wil je alleen aan de Amerikaanse kant van de watervallen blijven, maar toch het prachtige totaaloverzicht van de watervallen niet missen zoals je die in Canada kunt zien? Dan is de Observation Tower een hele goede optie om te bezoeken. Niet alleen heb je vanaf grote hoogte een uitzicht op alle drie de Niagara Falls, ook bij de voet van de toren heb je een goed overzicht op de American Falls. Vogelliefhebber? Bezoek dan ook de Observation Tower, je hebt kans op de Amerikaanse zeearend te spotten.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"8123\" img_size=\"large\" add_caption=\"yes\"][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"8127\" img_size=\"large\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"4.\" font_container=\"tag:div|font_size:75|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Goat Island\" font_container=\"tag:h3|font_size:45|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een andere must om te bezoeken aan de Amerikaanse kant is Goat Island. Goat Island is een klein eiland in de Niagara rivier, midden tussen de Bridal Veil Falls en de Horseshoe Falls. Het eiland is onderdeel van het Niagara Falls State Park en ligt in het zuid-westen van de stad Niagara Falls. Vanaf Goat Island heb je verschillende uitkijkpunten om de watervallen te bekijken. Via twee bruggen kun je het eiland bereiken per voet en auto. Op het eiland kun je naast de watervallen bekijken ook wandelen op de diverse wandelpaden.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Niagara Falls\" font_container=\"tag:div|font_size:65|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"E\u00e9n van de publiekstrekkers in het oosten van Amerika\" font_container=\"tag:div|font_size:40|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"8119\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Niagara Watervallen bezoeken - Tips voor excursies aan de Canadese kant\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"1.\" font_container=\"tag:div|font_size:75|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Journey behind the falls\" font_container=\"tag:h3|font_size:45|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Aan de Canadese kant van de Niagara Falls heb je de mogelijkheid om heel dicht bij de watervallen te komen. Met de Journey Behind the Falls ga je naar de plek waar de machtige Horseshoe Falls zich in de diepte storten. Via een doorkijkvenster heb je uitzicht op de achterkant van het watergordijn. Ook hier bevindt zich een platform vanwaar je de watervallen kunt bekijken. Let op, het kan glad zijn hier, dus doe schoenen met grip aan.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"8116\" img_size=\"large\" add_caption=\"yes\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"8122\" img_size=\"large\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"2.\" font_container=\"tag:div|font_size:75|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Niagara Whirpool\" font_container=\"tag:h3|font_size:45|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In de Niagara Gorge, stroomafwaarts van de Niagara Falls, bevindt zich de Niagara Whirpool. De Whirpool is een natuurlijke draaikolk in de rivier met een diepte van 38 meter. Wil je de Niagara Whirpool van dicht bij bekijken? Boek dan de Whirpool Aero Car, een kabelbaan waarmee je over het deel heen gaat.[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"3.\" font_container=\"tag:div|font_size:75|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Excursie met de Hornblower\" font_container=\"tag:h3|font_size:45|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De Hornblower is de Canadese versie van de Maid of Mist. Met de Hornblower boot vaar je naar de Niagara Falls, waarbij je heel dicht bij de watervallen komt. In ongeveer 20 minuten zie je alledrie de watervallen voorbij komen. Onderweg hoor je het geraas van het water dat naar beneden valt en ervaar je de mist die er vaak hangt. Een poncho (die wordt uitgereikt) is geen overbodige luxe.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"8115\" img_size=\"large\" add_caption=\"yes\"][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"8125\" img_size=\"large\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"4.\" font_container=\"tag:div|font_size:75|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"White Water Walk\" font_container=\"tag:h3|font_size:45|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De White Water Walk is een wandeling over een promenade langs de Niagara Falls. Het is een leuke manier om de kracht en schoonheid te zien van de watervallen. Vanaf hier zie je hoe de diepe en smalle Great Gorge is ontstaan. Je vindt de White Water Walk op 4 kilometer ten noorden van de watervallen, in de buurt van Whirpool Bridge. Je gaat met een lift 70 meter naar beneden en vervolgens loop je door een 73 meter lange tunnel. Je hebt daar 2 uitzichtpunten over de watervallen. De White Water Walk is geopend van april tot half november en zolang het weer het toelaat.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"5.\" font_container=\"tag:div|font_size:75|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Skylon Tower\" font_container=\"tag:h3|font_size:45|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Wil je genieten van een prachtig uitzicht van bovenaf? De <a href=\"https://www.getyourguide.com/niagara-falls-ontario-l87891/niagara-falls-skylon-tower-observation-deck-ticket-t148229/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=niagarafallsskylontower\" target=\"_blank\" rel=\"noopener\">Skylon Tower</a> aan Canadese zijde is hiervoor de beste plek. In nog geen 52 seconden ben je boven in de Skylon Tower. Je kijkt vanaf 160 meter hoogte uit over de watervallen en Niagara Falls centrum. Boven in de toren bevinden zich 2 restaurants en een observatiedek. Onderin de toren heb je een aantal giftshops, fastfood restaurants en arcade.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"8124\" img_size=\"large\" add_caption=\"yes\"][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"8120\" img_size=\"large\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Praktische tips voor een bezoek aan de Niagara Falls\" font_container=\"tag:h3|font_size:45|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]24/7 en 365 dagen geopend - de Niagara Falls zijn het hele jaar door te bezoeken, in de wintermaanden zijn niet alle excursies mogelijk[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: voorjaar en najaar[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]Gratis, maar de excursies en bezienswaardigheden kosten wel geld[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-history\" content_font_size=\"desktop:16px;\"]Minimaal 2 dagen verblijven[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-location-arrow\" content_font_size=\"desktop:16px;\"]+10 bezienswaardigheden[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-bed hotel\" content_font_size=\"desktop:16px;\"]Overnachten in <a href=\"https://www.booking.com/searchresults.en.html?city=20088351&amp;aid=7958498&amp;no_rooms=1&amp;group_adults=2&amp;label=niagarafallsalgemeen\" target=\"_blank\" rel=\"noopener\">Niagara Falls</a>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][ultimate_heading main_heading=\"Tours &amp; rondleidingen in Niagara Falls\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Met deze tours en attracties in de Niagara Falls, haal je het ultieme uit je trip. Van varen tussen de watervallen tot avontuurlijker: Met een zipline langs de Niagara Watervallen.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"8124\" img_size=\"large\" add_caption=\"yes\"][ultimate_heading main_heading=\"Skylon Tower-observatiedek\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][ultimate_heading main_heading=\"Vanaf \u20ac58\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_margin=\"margin-top:5px;margin-bottom:5px;\"][/ultimate_heading][vc_column_text]Liever hoog en droog de wonderen van de Niagara Falls aanschouwen? Kies dan voor een\u00a0onovertroffen uitzicht op de Niagara watervallen en de omliggende stad vanaf de Skylon Tower. Hier heb je\u00a0adembenemende 360\u00b0 panoramische vergezichten vanaf het 236-meter hoge observatiedek waarbij je zowel binnen als buiten de Niagara Falls kunt aanschouwen.[/vc_column_text][ultimate_heading main_heading=\"Praktische informatie\" heading_tag=\"div\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_column_text]<b>Handig:</b>\u00a0 Flexibel ticket, je bepaalt zelf wanneer je gaat\r\n<b>Vertrek</b>: Skylon Tower, Robinson Street 5200\r\n<b>Let op</b>: Mensen met hoogtevrees, je gaat in een glazen buitenlift omhoog...[/vc_column_text][ult_buttons btn_title=\"Boek deze tour\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fniagara-falls-ontario-l87891%2Fniagara-falls-canada-ticket-skylon-tower-observatiedek-t148229%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3DNiagara-falls|title:Boek%20deze%20rondleiding|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"11017\" img_size=\"large\" add_caption=\"yes\"][ultimate_heading main_heading=\"Zipline langs de Niagara Falls\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][ultimate_heading main_heading=\"Vanaf \u20ac41\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_margin=\"margin-top:5px;margin-bottom:5px;\"][/ultimate_heading][vc_column_text]Met een bootje varen langs de Niagara Falls te saai? Dan is deze 'adventure-thrill' zipline langs de watervallen \u00e9cht iets voor jou. Sterker nog, dit is een typische toevoeging voor aan je bucketlist. Je hangt\u00a067 meter boven de canyon van de Niagara River en zweeft 670 meter langs de Amerikaanse watervallen naar de voet van de machtige Canadese Horseshoe Falls.[/vc_column_text][ultimate_heading main_heading=\"Praktische informatie\" heading_tag=\"div\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_column_text]<b>Duur:</b>\u00a0 1 uur (inclusief instructies)\r\n<b>Vertrek</b>: 5920 Niagara Parkway\r\n<b>Let op: </b>Neem waterbestendige schoenen mee![/vc_column_text][ult_buttons btn_title=\"Boek deze tour\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fziplijn-naar-de-falls-l91520%2Fcanadese-niagarawatervallen-tokkelbaan-naar-de-watervallen-t164966%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3DNiagara-falls|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"8117\" img_size=\"large\" add_caption=\"yes\"][ultimate_heading main_heading=\"Maid of the Mist-boottocht inclusief eten bij Hard Rock Cafe\" main_heading_color=\"#b34a4c\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\"][/ultimate_heading][ultimate_heading main_heading=\"Vanaf \u20ac105\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_margin=\"margin-top:5px;margin-bottom:5px;\"][/ultimate_heading][vc_column_text]Met deze Maid of the Mist-boottocht maak je een onvergetelijke reis om de adembenemende schoonheid van de Niagara Falls watervallen van dichtbij te zien. Trek een poncho aan, want je we kunnen je \u00e9\u00e9n ding garanderen: nat, natter, natst! Na een een opwindende tour door de Niagara-watervallen, is er een begeleide wandeling in het Niagara Falls State Park.[/vc_column_text][ultimate_heading main_heading=\"Praktische informatie\" heading_tag=\"div\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_column_text]<b>Duur:</b>\u00a0 In totaal 2 uur\r\n<b>Vertrek</b>: Hard Rock Cafe\r\n<b>Let op: </b>Fooien zijn niet inbegrepen[/vc_column_text][ult_buttons btn_title=\"Boek deze tour\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fniagara-falls-usa-l87888%2Fniagara-falls-maid-of-the-mist-ticket-and-guided-tour-t426371%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dniagaramaidofthemist|title:Boek%20deze%20tour|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"95%\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space][fullwidth_row][vc_custom_heading text=\"Andere interessante artikelen\" font_container=\"tag:div|font_size:65|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"size:4|order_by:date|order:DESC|post_type:post|categories:63,62\"][/vc_column][/vc_row]","post_title":"De Niagara Falls &#8211; tips voor een bezoek aan de Niagara watervallen","post_link":"https://www.heyusa.com/nl/niagara-falls/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Niagara Falls\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/08/niagara-falls-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Natuur","post_tags":"New York","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1680082017:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"15","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"8121","%_wpgmp_location_address%":"Niagara Falls, New York, Verenigde Staten","%_wpgmp_location_city%":"Niagara Falls","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"43.0962143","%_wpgmp_metabox_longitude%":"-79.0377388","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Niagara watervallen\"]","%_yoast_wpseo_focuskw%":"Niagara Falls","%_yoast_wpseo_metadesc%":"De Niagara Falls, tips voor een bezoek aan de Niagara watervallen. Tips voor excursies aan de Amerikaanse en Canadese kant van de Niagara Falls","%_yoast_wpseo_linkdex%":"80","%_yoast_wpseo_primary_category%":"63","%_yoast_wpseo_title%":"De Niagara Falls - tips voor een bezoek aan de Niagara watervallen%%page%%","%_yoast_wpseo_estimated-reading-time-minutes%":"9","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015181","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Natuur","taxonomy=post_tag":"New York","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png"},"id":8105,"infowindow_disable":false},{"source":"post","title":"Mission Dolores Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Mission Dolores Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/07/Mission-Dolores-park1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Mission Dolores Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Dolores St &, 19th St, San Francisco, CA 94114, Verenigde Staten","location":{"lat":"37.75958609999999","city":"San Francisco","state":"California","country":"Verenigde Staten","lng":"-122.4269083","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/mission-dolores-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"25px\"][ultimate_heading main_heading=\"Samensmelting van Castro en Mission District\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][ultimate_heading main_heading=\"Op de groene heuvels van San Francisco\" heading_tag=\"div\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Mission Dolores Park\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Met ongeveer 6 hectare is het Mission Dolores Park in San Francisco de escape voor inwoners van Mission District en Castro. Het is een heerlijk park waar veel mensen komen om uit beiden buurten om te genieten van het buitenzijn. Het is de plek om te relaxen of aan sport te doen voor de inwoners rondom Mission Dolores Park.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Mission Dolores\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]De naam Mission Dolores komt van de Spaanse missie in San Francisco rond 1750. De kerk staat nog steeds in de wijk <a href=\"https://www.heyusa.com/nl/san-francisco/the-mission/\" target=\"_blank\" rel=\"noopener\">Mission District</a> en draagt dezelfde naam als destijds. Na 1960 werd het park in de volksmond steeds vaker Dolores Park in plaats van Mission Park genoemd. Tegenwoordig wordt de naam Mission Park nog amper gebruikt hoewel de offici\u00eble naam sinds 2016 Mission Dolores Park is.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Wat te doen in het Mission Dolores Park\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Het park is natuurlijk een stuk kleiner dan het grote Golden Gate Park en heeft daardoor minder bezienswaardigheden om te bezoeken. Het park wordt vooral gebruikt als de plek om samen buiten te zijn door de locals. Er zijn veel sport- en speel mogelijkheden in het park dat een warm en zonnig microklimaat heeft. Het Mission Dolores Park bevindt zich op een heuvel en daardoor heb je in het park uitzicht over het noordoosten van het centrum van San Francisco. Het park is sinds de jaren '60 ook de plek waar vele evenementen worden gehouden.[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"7430\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"LENTE &amp; ZOMER\" heading_tag=\"p\" main_heading_color=\"#000000\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">De grasvelden stromen in de zomermaanden vol met locals die willen genieten van het buiten zijn. Of ze aan het relaxen zijn met uitzicht over het centrum van San Francisco of gebruik maken van een van de sportmogelijkheden, in deze maanden is Mission Dolores Park de plek voor inwoners van The Mission en Castro. Het is ook de periode waarin vele evenementen worden gehouden in het park.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"7429\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"WINTER &amp; KERST\" heading_tag=\"p\" main_heading_color=\"#000000\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Wanneer het langzaam kouder wordt, is het Mission Dolores Park nog steeds een aanrader om te bezoeken. Door het microklimaat in de wijk Mission District is het nooit echt heel koud in het park. Het is gemiddeld zelfs 5 graden warmer dan in andere buurten van San Francisco. Dus ook in het najaar is het Mission Dolores Park een goede optie voor een picknick en ondertussen mensen kijken.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][parallax_row image=\"3336\"][vc_empty_space height=\"350px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][ultimate_heading main_heading=\"E\u00e9n en al gezelligheid\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_custom_heading text=\"Must do: picknicken in het park\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"350px\"][/vc_column][/vc_row]","post_title":"Mission Dolores Park","post_link":"https://www.heyusa.com/nl/mission-dolores-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Mission Dolores Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/07/Mission-Dolores-park1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Parken San Francisco","post_tags":"","%inline_featured_image%":"0","%_edit_last%":"1","%_edit_lock%":"1665476809:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"50","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%_hide_featured%":null,"%post_via%":"","%_yoast_wpseo_focuskw%":"Mission Dolores Park San Francisco","%_yoast_wpseo_title%":"Mission Dolores Park San Francisco%%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Wat te doen in het Mission Dolores Park San Francisco? Tips voor bezienswaardigheden in Mission Dolores Park in San Francisco.","%_yoast_wpseo_linkdex%":"73","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_primary_category%":"56","%_wpgmp_location_address%":"Dolores St &, 19th St, San Francisco, CA 94114, Verenigde Staten","%_wpgmp_location_city%":"San Francisco","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"37.75958609999999","%_wpgmp_metabox_longitude%":"-122.4269083","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_thumbnail_id%":"7431","%standard-featured-credit%":"De ingang van Golden Gate Park in San Francisco","%thb-reactions-votes%":"1","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015217","taxonomy=category":"Parken San Francisco","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/park-icon.png"},"id":7426,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/park-icon.png","name":"Parken","id":"3","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"The Dupont Circle Hotel","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Dupont Circle Hotel in Washington DC\" width=\"300\" height=\"169\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/06/dupont-circle-hotel-suite-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">The Dupont Circle Hotel</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1500 New Hampshire Ave NW, Washington, DC 20036, Verenigde Staten","location":{"lat":"38.9105236","city":"Washington","state":"District of Columbia","country":"Verenigde Staten","lng":"-77.042981","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/overnachten-in-washington-dc/dupont-circle-hotel/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Fancy hotel in hippe wijk van Washington DC\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][ultimate_heading main_heading=\"1500 New Hampshire Avenue NW, Washington DC\" heading_tag=\"div\" main_heading_font_family=\"font_family:Oswald|font_call:Oswald\" main_heading_font_size=\"desktop:30px;\" main_heading_line_height=\"desktop:35px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"The Dupont Cicle Hotel in Washington DC\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"$$$$\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]In tegenstelling tot het budgetvriendelijke <a href=\"https://www.heyusa.com/nl/overnachten-in-washington-dc/citizenm-hotel/\">citizenM hotel in Washington DC</a>, zijn de kamers in het Dupont Circle Hotel een stuk hoger. Maar daarvoor krijg je absoluut klasse en grandeur voor terug. Het Dupont Circle Hotel is geen standaard premium hotel met een klassieke uitstraling, dit hotel brengt klassiek grandeur samen met hedendaags design. Een beetje 'klassiek meets cool'. De standaard kamers zijn ruim en voorzien van alle gemakken en zijn qua prijs vergelijkbaar met andere 4 en 5 sterrenhotels. Maar de suites: mama mia, die zijn geschikt voor een premier of president. Met een eigen gigantisch terras, butler, woonkamer en een ligbad met uitzicht over Washington DC. Daar betaal je dan wel $7000 per nacht voor... ;) Het Dupont Circle hotel ligt in de gelijknamige, hippe wijk van Washington DC.[/vc_column_text][ultimate_heading main_heading=\"Geselecteerd door Hey!USA\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]Het Dupont Circle Hotel in Washington DC is door Hey!USA geselecteerd omdat dit hotel een eigentijdse uitstraling heeft, gelegen in een hippe wijk. Het is verreweg een 'standaard' hotel en de sfeer en inrichting van het hotel hebben een klassieke cool-factor. Toegegeven, het hotel ligt niet op loopafstand van de Mall, maar het Dupont Circle Hotel ligt aan een grote rotonde waarop een mini parkje te vinden is. Tegenover het hotel ligt de metrohalte van Dupont Circle, waarmee je in no-time naar het centrum van DC kunt reizen. Dat duurt ongeveer 8 minuten tot het Witte Huis.[/vc_column_text][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fthe-dupont.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dheyusa_website|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"6565,6566,6567,6568,6569,6556\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"6567\" img_size=\"large\" add_caption=\"yes\" style=\"vc_box_shadow_3d\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Rondom Dupont Circle, waar het gelijknamige hotel gevestigd is, vind je verschillende restaurants, winkels, ketens als Dunkin' en koffiecaf\u00e9s. De metrohalte ligt tegenover het hotel. Op slechts 5 minuten wandelen vind je Embassy Row, hier zijn talloze ambassades van verschillende landen te vinden. Kijk dan ook niet verbaasd op wanneer je een bekende politicus tegenkomt in het hotel. Het inpandige restaurant 'The Pembroke' staat hoog aangeschreven in Washington DC, maar is verrassend betaalbaar![/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Toplocatie\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"Gratis WiFi\"][thb_iconlist icon=\"fas fa-utensils\" list_content=\"Restaurant\"][thb_iconlist icon=\"fas fa-glass-cheers\" list_content=\"Bar met uitzicht over Dupont Circle\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Comfortabele bedden\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fthe-dupont.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dheyusa_website|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"The Dupont Circle Hotel","post_link":"https://www.heyusa.com/nl/overnachten-in-washington-dc/dupont-circle-hotel/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Dupont Circle Hotel in Washington DC\" width=\"300\" height=\"169\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/06/dupont-circle-hotel-suite-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Overnachten in Washington DC","post_tags":"","%inline_featured_image%":"0","%_edit_lock%":"1669732473:1","%_edit_last%":"1","%_yoast_wpseo_primary_category%":"110","%_thumbnail_id%":"6556","%_hide_featured%":null,"%_wpgmp_location_address%":"1500 New Hampshire Ave NW, Washington, DC 20036, Verenigde Staten","%_wpgmp_location_city%":"Washington","%_wpgmp_location_state%":"District of Columbia","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.9105236","%_wpgmp_metabox_longitude%":"-77.042981","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"13\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%post-primary-category%":"auto","%featured_image_override%":"off","%standard-featured-credit%":"CitizenM Hotel Times Square","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_focuskw%":"Dupont Circle hotel Washington DC","%_yoast_wpseo_metadesc%":"Logeren als een president of premier in Washington DC? Het stijlvolle Dupont Circle Hotel combineert klasse uitstraling met een cool-factor.","%_yoast_wpseo_linkdex%":"62","%post_source%":[{"title":"Fotografie: Dupont Circle Hotel","post_source_url":"https://www.doylecollection.com/hotels/the-dupont-circle-hotel/"}],"%_yoast_indexnow_last_ping%":"1677015253","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Overnachten in Washington DC","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png"},"id":6555,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png","name":"Hotels","id":"13","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"citizenM Washington DC","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Een hotelkamer in het citizenM hotel in Washington DC\" width=\"300\" height=\"220\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/06/citizenm-washingtondc-300x220.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">citizenM Washington DC</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"550 School St SW, Washington, DC 20024, Verenigde Staten","location":{"lat":"38.88373939999999","city":"Washington","state":"District of Columbia","country":"Verenigde Staten","lng":"-77.019488","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/overnachten-in-washington-dc/citizenm-hotel/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Innovatief in Washington DC\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][ultimate_heading main_heading=\"550 School Street SW, Washington DC\" heading_tag=\"div\" main_heading_font_family=\"font_family:Oswald|font_call:Oswald\" main_heading_font_size=\"desktop:30px;\" main_heading_line_height=\"desktop:35px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"citizenM Hotel in Washington DC\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"$$$\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Net als het <a href=\"https://www.heyusa.com/nl/overnachten-in-new-york-city/citizenm/\">citizenM in Times Square New York</a>, bedien je in dit hotel heel je hotelkamer met een app. Van je gordijnen, de lichten, de temperatuur tot de gratis films op je televisie. Het citizenM Hotel in Washington DC, heeft een ideale ligging, dichtbij de Mall, het Capitool en de vele musea. Bovendien is het ook nog eens een budget friendly hotel. Net als alle andere citizenM hotels wereldwijd, zijn alle hotelkamers bijna identiek, met een grote douche, een goed bed en de handige app, waarmee je alles in je kamer regelt. Vanaf het terras in canteenM heb je mooi uitzicht op het Capitool![/vc_column_text][ultimate_heading main_heading=\"Geselecteerd door Hey!USA\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]CitizenM in Washington DC is door Hey!USA geselecteerd omdat dit hotel een ideale ligging heeft en met z'n slimme en innovatieve inrichting veel meer biedt dan enkel een budgetvriendelijk alternatief. Inchecken, dat doe je gewoon zelf via de computers in de lobby, je hoeft dus niet lang te wachten in een rij. In de hotelkamer is de speciale CitizenM app je beste vriend. De lobby, canteenM en de publieke ruimtes zijn tof ingericht, het hotel heeft ook verschillende vergaderzalen en je kunt er remote werken. Kortom, een ideaal hotel, goede ligging en absoluut een aanrader.[/vc_column_text][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fcitizenm-washington-dc-capitol.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dheyusa_website|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"6543,6544,6545,6546,6547,6548\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"6545\" img_size=\"large\" add_caption=\"yes\" style=\"vc_box_shadow_3d\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]CitizenM Hotel in Washington DC ligt super centraal, slechts 5 minuten van de Mall, waar je alle Nationale Musea gratis kunt bezoeken. Het Capitool is een kleine 10 minuten van citizenM te vinden. De dichtstbijzijnde metro is een kleine 10min van het hotel te vinden. Op wandelafstand ben je ook in The Warf, de bruisende wijk aan het Washington kanaal met restaurants, theaters en leuke winkels.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Toplocatie\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"Gratis WiFi\"][thb_iconlist icon=\"fas fa-utensils\" list_content=\"Restaurant\"][thb_iconlist icon=\"fas fa-glass-cheers\" list_content=\"Terras met skyline\"][thb_iconlist icon=\"fas fa-dollar-sign\" list_content=\"Budgetvriendelijk\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Comfortabele bedden\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fcitizenm-washington-dc-capitol.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dheyusa_website|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"citizenM Washington DC","post_link":"https://www.heyusa.com/nl/overnachten-in-washington-dc/citizenm-hotel/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Een hotelkamer in het citizenM hotel in Washington DC\" width=\"300\" height=\"220\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/06/citizenm-washingtondc-300x220.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Overnachten in Washington DC","post_tags":"","%inline_featured_image%":"0","%_edit_lock%":"1664554589:1","%_edit_last%":"1","%_yoast_wpseo_primary_category%":"110","%_thumbnail_id%":"6514","%_hide_featured%":null,"%_wpgmp_location_address%":"550 School St SW, Washington, DC 20024, Verenigde Staten","%_wpgmp_location_city%":"Washington","%_wpgmp_location_state%":"District of Columbia","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.88373939999999","%_wpgmp_metabox_longitude%":"-77.019488","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"13\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%post-primary-category%":"auto","%featured_image_override%":"off","%standard-featured-credit%":"CitizenM Hotel Times Square","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_focuskw%":"citizenM hotel Washington DC","%_yoast_wpseo_metadesc%":"Het citizenM hotel in Washington DC is een budgetvriendelijk hotel, dichtbij de Mall, de vele musea en het Capitool.","%_yoast_wpseo_linkdex%":"68","%post_source%":[{"title":"Fotografie: CitizenM","post_source_url":"https://www.citizenm.com/hotels/united-states/washington-dc/washington-dc-capitol-hotel"}],"%_yoast_indexnow_last_ping%":"1677015256","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Overnachten in Washington DC","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png"},"id":6511,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png","name":"Hotels","id":"13","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"CitizenM Times Square","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"CitizenM Times Square\" width=\"300\" height=\"165\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/05/citizenm-hotel-timessquare-300x165.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">CitizenM Times Square</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"218 W 50th St, New York, NY 10019, Verenigde Staten","location":{"lat":"40.76156530000001","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.9849546","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/overnachten-in-new-york-city/citizenm/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Innovatief hotel nabij Times Square\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][ultimate_heading main_heading=\"218 W 50th Street, Manhattan, New York City\" heading_tag=\"div\" main_heading_font_family=\"font_family:Oswald|font_call:Oswald\" main_heading_font_size=\"desktop:30px;\" main_heading_line_height=\"desktop:35px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"CitizenM Times Square\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"$$$\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]In dit innovatieve hotel bedien je heel je hotelkamer met een app. Van je gordijnen, de lichten, de temperatuur tot de gratis films op je televisie. CitizenM Hotel nabij <a href=\"https://www.heyusa.com/nl/new-york/times-square/\" target=\"_blank\" rel=\"noopener\">Times Square</a> in Manhattan, is een budget friendly hotel... maar alles behalve een budget uitstraling. Elke kamer van het 230 kamer tellend hotel is bijna identiek, met een grote douche, een goed bed en natuurlijk de handige app waarmee je alles in je kamer regelt. CitizenM Times Square heeft \u00f3\u00f3k een leuke rooftop bar: cloudM en in canteenM kun je 24/7 eten bestellen.[/vc_column_text][ultimate_heading main_heading=\"Geselecteerd door Hey!USA\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]CitizenM Times Square is door Hey!USA geselecteerd omdat dit hotel een uniek concept heeft. Dat begint al bij het inchecken, dat doe je gewoon zelf via de computers in de lobby. In je kamer, bedien je ook alles met de speciale CitizenM app, waar je overigens ook speciale kortingen en goodies kunt vinden. Hoewel de kamers niet groot zijn, zoals veel hotels in New York, zijn ze slim en innovatief ingericht. Elke kamer, waar ook ter wereld, ziet er ongeveer hetzelfde uit! De lobby, rooftop bar en het restaurant zijn tof ingericht, niets straalt hier dan ook uit dat je in een budget vriendelijk hotel logeert.[/vc_column_text][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fcitizenm-new-york-times-square-new-york.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dheyusa_website|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"6498,6499,6500,6501,6502\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"6500\" img_size=\"large\" add_caption=\"yes\" style=\"vc_box_shadow_3d\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]CitizenM Times Square ligt super centraal, slechts 2 straten van Times Square. Vanaf hier heb je verschillende metrolijnen, winkels, restaurants \u00e9n de M&amp;M Store vind je om de hoek.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Toplocatie\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"Gratis WiFi\"][thb_iconlist icon=\"fas fa-utensils\" list_content=\"Restaurant\"][thb_iconlist icon=\"fas fa-glass-cheers\" list_content=\"Rooftopbar\"][thb_iconlist icon=\"fas fa-dollar-sign\" list_content=\"Budgetvriendelijk\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Comfortabele bedden\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fcitizenm-new-york-times-square-new-york.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dheyusa_website|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Andere hotels in New York City:\" main_heading_color=\"#b34a4c\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"25px\"][thb_postgrid style=\"style4\" columns=\"4\" source=\"size:8|post_type:post|categories:109\"][/vc_column][/vc_row]","post_title":"CitizenM Times Square","post_link":"https://www.heyusa.com/nl/overnachten-in-new-york-city/citizenm/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"CitizenM Times Square\" width=\"300\" height=\"165\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/05/citizenm-hotel-timessquare-300x165.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Overnachten in New York City","post_tags":"","%inline_featured_image%":"0","%_edit_lock%":"1669734674:1","%_edit_last%":"1","%_yoast_wpseo_primary_category%":"109","%_thumbnail_id%":"6280","%_hide_featured%":null,"%_wpgmp_location_address%":"218 W 50th St, New York, NY 10019, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.76156530000001","%_wpgmp_metabox_longitude%":"-73.9849546","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"13\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%post-primary-category%":"auto","%featured_image_override%":"off","%standard-featured-credit%":"CitizenM Hotel Times Square","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_focuskw%":"CitizenM Times Square","%_yoast_wpseo_metadesc%":"Het CitizenM hotel op Times Square is een budgetvriendelijk hotel in New York met een coole inrichting \u00e9n rooftop bar!","%_yoast_wpseo_linkdex%":"69","%post_source%":[{"title":"Fotografie: CitizenM","post_source_url":"https://www.citizenm.com/hotels/united-states/new-york/new-york-times-square-hotel"}],"%_yoast_indexnow_last_ping%":"1677015274","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Overnachten in New York City","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png"},"id":6279,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png","name":"Hotels","id":"13","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Moxy Hotel","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Moxy Hotel Times Square in New York\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/05/moxy-hotel-timessquare-newyork-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Moxy Hotel</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"485 7th Ave, New York, NY 10018, Verenigde Staten","location":{"lat":"40.7523124","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.9891195","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/overnachten-in-newyork-city/moxy-hotel/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Modern Retro Hotel nabij Times Square\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][ultimate_heading main_heading=\"485 7th Avenue, Manhattan, New York City\" heading_tag=\"div\" main_heading_font_family=\"font_family:Oswald|font_call:Oswald\" main_heading_font_size=\"desktop:30px;\" main_heading_line_height=\"desktop:35px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Moxy Hotel Times Square\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"$$$\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Zoals veel hotels in New York zijn de hotelkamers klein, zo ook bij Moxy. Maar 'size doesn't matter' en de kamers zijn heel erg cool, dat compenseert ongetwijfeld de afmetingen. Moxy Hotel ligt nabij <a href=\"https://www.heyusa.com/nl/new-york/times-square/\" target=\"_blank\" rel=\"noopener\">Times Square</a> in Manhattan en is volledig ingericht in een 'retro meets industrial' stijl. Elke hoek, kamer en bar zijn een plezier voor je ogen. De kamers zijn niet groot, maar innovatief ingericht en de ruimte wordt optimaal benut. Op het dak van het hotel vind je \u00e9\u00e9n van de coolste rooftopbars van heel New York: Magic Hour. Ook het inpandige restaurant 'Legasea', een visrestaurant, is de moeite waard![/vc_column_text][ultimate_heading main_heading=\"Geselecteerd door Hey!USA\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]The Moxy Hotel is door Hey!USA geselecteerd omdat dit hotel, ondanks onderdeel te zijn van een keten (Marriot Hotels), je hier een \u00e9cht boutique hotel krijgt voor een redelijke prijs. Zelfs de goedkoopste kamer, met twee stapelbedden, heeft een coolfactor. D\u00e9 eyecatcher van het hotel is ongetwijfeld de rooftopbar Magic Hour (enkel vanaf 21 jaar). Waar je een klein hapje kunt eten, goede cocktails krijgt \u00e9n kunt gaan minigolfen. Met ruim 600 kamers is het Moxy Hotel overigens een flink hotel nabij Times Square.[/vc_column_text][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fmoxy-nyc-times-square.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dheyusa_website|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"6271,6272,6273,6277,6274,6275,6276\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"6276\" img_size=\"large\" add_caption=\"yes\" style=\"vc_box_shadow_3d\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]The Moxy Times Square ligt slechts 650m van Bryant Park en 600m van Times Square. Rondom het hotel vind je verschillende winkels en restaurants. Slechts 1 blok van het hotel ligt Macy's en de winkelstraat 34th Street. De dichtstbijzijnde metrohalte ligt op slechts 3 minuten wandelen in Penn Station.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Toplocatie\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"Gratis WiFi\"][thb_iconlist icon=\"fas fa-utensils\" list_content=\"Restaurants\"][thb_iconlist icon=\"fas fa-glass-cheers\" list_content=\"Rooftopbar\"][thb_iconlist icon=\"fas fa-concierge-bell\" list_content=\"Roomservice\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Comfortabele bedden\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fmoxy-nyc-times-square.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dheyusa_website|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Andere hotels in New York City:\" main_heading_color=\"#b34a4c\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"25px\"][thb_postgrid style=\"style4\" columns=\"4\" source=\"size:8|post_type:post|categories:109\"][/vc_column][/vc_row]","post_title":"Moxy Hotel","post_link":"https://www.heyusa.com/nl/overnachten-in-newyork-city/moxy-hotel/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Moxy Hotel Times Square in New York\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/05/moxy-hotel-timessquare-newyork-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Overnachten in New York City","post_tags":"","%inline_featured_image%":"0","%_edit_lock%":"1675427505:1","%_edit_last%":"1","%_yoast_wpseo_primary_category%":"109","%_thumbnail_id%":"6268","%_hide_featured%":null,"%_wpgmp_location_address%":"485 7th Ave, New York, NY 10018, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7523124","%_wpgmp_metabox_longitude%":"-73.9891195","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"13\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%post-primary-category%":"auto","%featured_image_override%":"off","%standard-featured-credit%":"Moxy Hotel Times Square","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_focuskw%":"made hotel","%_yoast_wpseo_metadesc%":"Het Moxy Hotel nabij Times Square is een #cool hotel met vintage uitstraling. De retro en industri\u00eble look van het hotel zijn heel gaaf!","%_yoast_wpseo_linkdex%":"51","%post_source%":[{"title":"Fotografie: Moxy Hotel","post_source_url":"https://www.marriott.com/hotels/travel/nycox-moxy-nyc-times-square/"}],"%_yoast_indexnow_last_ping%":"1677015276","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Overnachten in New York City","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png"},"id":6266,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png","name":"Hotels","id":"13","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Williamsburg Hotel","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Williamsburg Hotel in Brooklyn\" width=\"300\" height=\"169\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/05/williamsburg-hotel-skyline-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Williamsburg Hotel</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"96 Wythe Ave, Brooklyn, NY 11249, Verenigde Staten","location":{"lat":"40.7215045","state":"New York","country":"Verenigde Staten","lng":"-73.9587016","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/overnachten-in-new-york-city/williamsburg-hotel/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"#cool hotel in Williamsburg, Brooklyn\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][ultimate_heading main_heading=\"96 Wythe Avenue, Brooklyn, New York City\" heading_tag=\"div\" main_heading_font_family=\"font_family:Oswald|font_call:Oswald\" main_heading_font_size=\"desktop:30px;\" main_heading_line_height=\"desktop:35px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Williamsburg Hotel\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"$$$$\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Dit is ongetwijfeld \u00e9\u00e9n van de coolste hotels in <a href=\"https://www.heyusa.com/nl/new-york/williamsburg/\">Williamsburg</a> in de borough <a href=\"https://www.heyusa.com/nl/newyork/brooklyn/\">Brooklyn</a>. Het Williamsburg Hotel is ingericht in een chique-industri\u00eble stijl met een dosis coolness. De meeste kamers hebben een klein terras met uitzicht op de skyline van Manhattan. Hierdoor is het na een lange dag in NYC leuk om met een flesje op je eigen terras tot rust te komen. Op het dak van het hotel vind je een rooftop-pool \u00e9n supergave bar, in de vorm van een typisch New Yorkse watertoren. Met 54 kamers, is The Williamsburg Hotel voor New Yorkse begrippen een klein hotel.[/vc_column_text][ultimate_heading main_heading=\"Geselecteerd door Hey!USA\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]The Williamsburg Hotel is door Hey!USA geselecteerd omdat dit hotel een echte 'experience' te bieden heeft. De hotelkamers, zelfs de goedkoopste kamers, zijn ontzettend cool ingericht. Vooral de rooftop-pool en de 'Watertower' bar zijn d\u00e9 eyecatchers van het hotel. Het hotel organiseert bovendien regelmatig muziek sessies op het dak en de twee inpandige restaurants zijn \u00f3\u00f3k de moeite waard.[/vc_column_text][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fthe-williamsburg.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dheyusa_website|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"6243,6244,6245,6246,6247\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"6247\" img_size=\"large\" add_caption=\"yes\" style=\"vc_box_shadow_3d\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]The Williamsburg Hotel ligt dichtbij Bedford Avenue, waar ook de enige metrohalte van Williamsburg te vinden is. Rondom het hotel zijn verschillende hotspots, zoals de Brooklyn Brewery en Bushwick Inlet Park. Met de metro ben je in ongeveer 15min in Manhattan.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Toplocatie\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"Gratis WiFi\"][thb_iconlist icon=\"fas fa-utensils\" list_content=\"Restaurants\"][thb_iconlist icon=\"fas fa-swimmer\" list_content=\"Zwembad\"][thb_iconlist icon=\"fas fa-glass-cheers\" list_content=\"Bar\"][thb_iconlist icon=\"fas fa-concierge-bell\" list_content=\"Roomservice\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Comfortabele bedden\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fthe-williamsburg.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dheyusa_website|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Andere hotels in New York City:\" main_heading_color=\"#b34a4c\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"25px\"][thb_postgrid style=\"style4\" columns=\"4\" source=\"size:8|post_type:post|categories:109\"][/vc_column][/vc_row]","post_title":"Williamsburg Hotel","post_link":"https://www.heyusa.com/nl/overnachten-in-new-york-city/williamsburg-hotel/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Williamsburg Hotel in Brooklyn\" width=\"300\" height=\"169\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/05/williamsburg-hotel-skyline-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Overnachten in New York City","post_tags":"","%inline_featured_image%":"0","%_edit_lock%":"1680509343:2","%_edit_last%":"1","%_yoast_wpseo_primary_category%":"109","%_thumbnail_id%":"6242","%_hide_featured%":null,"%_wpgmp_location_address%":"96 Wythe Ave, Brooklyn, NY 11249, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7215045","%_wpgmp_metabox_longitude%":"-73.9587016","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"13\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%post-primary-category%":"auto","%featured_image_override%":"off","%standard-featured-credit%":"The Williamsburg Hotel, Brooklyn","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_focuskw%":"made hotel","%_yoast_wpseo_metadesc%":"Het Williamsburg Hotel in Brooklyn is \u00e9\u00e9n van de #coolste hotels van Williamsburg. De meeste kamers hebben een eigen balkon! Een wow hotel in Brooklyn.","%_yoast_wpseo_linkdex%":"43","%post_source%":[{"title":"Fotografie: The Williamsburg Hotel","post_source_url":"https://www.thewilliamsburghotel.com"}],"%_yoast_indexnow_last_ping%":"1677015278","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Overnachten in New York City","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png"},"id":6238,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png","name":"Hotels","id":"13","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Oregon Dunes National Recreation Area","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Oregon Dunes\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/05/Oregon-Dunes-duinen-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Oregon Dunes National Recreation Area</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"855 US-101, Reedsport, OR 97467, Verenigde Staten","location":{"lat":"43.7035323","city":"Reedsport","state":"Oregon","country":"Verenigde Staten","lng":"-124.1059618","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/oregon-dunes-national-recreation-area/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Oregon Dunes National Recreation Area\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In de Amerikaanse staat Oregon vind je een duingebied zoals wij dat kennen van de Nederlandse kust. Het Oregon Dunes National Recreation Area lijkt in eerste instantie op de duingebieden in Nederland. Toch zijn de duinen van Oregon het bezoeken waard. Waarom? Het is namelijk een van de grootste duingebieden ter wereld, er komen dieren voor die je nergens anders ziet en je kunt er een toffe activiteit ondernemen! Tips voor een bezoek aan de Oregon Dunes.[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Geen entree[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]24 Fort Missoula Road, Missoula[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612950540814{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"De duinen van Oregon\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Oregon heeft een fantastische ruige kustlijn. Op sommige plekken domineren hoge kliffen het beeld. In het zuiden van de staat vind je een gebied dat voor het grote deel bestaat uit zand afgewisseld met bossen en duinen. Oregon Dunes is het grootste duinengebied van Amerika en doet niet veel onder voor andere duingebieden in de wereld qua grootte. Sommige duinen hebben een hoogte van meer dan 150 meter. De gehele kustlijn is meer dan 60 kilometer, een enorm gebied om te ontdekken!</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"De vele duinen in Oregon\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"De jongste duin is 7000 jaar oud\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"6232\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Must do - Off Highway Vehicle\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Waar je in Nederland vaak alleen kan wandelen in een duingebied, staan de Oregon Dunes bekend om een activiteit met iets meer adrenaline. Je kunt in het Oregon Dunes National Recreation Area off-road rijden. Met een 'buggy' rijd je dwars door de duinen van Oregon. In de beginjaren mocht je in meer dan 90% van het park off-road rijden, inmiddels is het nog 30%. Om de natuur te beschermen zijn er twee rijzones die je kunt gebruiken: North Middle en South OHV. Dus wil je het gebied op een andere manier bekijken? Stap dan in een off highway vehicle (OHV)[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Tips voor Oregon Dunes National Recreation Area\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Naast OHV rijden zijn er nog tal van andere activiteiten die je kunt ondernemen in het duingebied. Allereerst moet je weten dat er 4 verschillende zones zijn in het gebied: South Jetty, Siltcoos, Oregon Dunes Day Use en Tahkenitch. Zo kun je in de eerste twee gebieden wel Off Highway Vehicles tegen komen, maar in de laatste twee niet. Deze gebieden zijn meer geschikt om het duingebied te voet te verkennen. Wil je kort kennismaken met de Oregon Dunes? Kies er dan voor om naar het Oregon Dunes Day Use Area af te reizen. Hier vind je een uitkijkplatform en een aantal mogelijkheden voor (korte) wandelingen. Andere activiteiten die je in het gebied kunt ondernemen zijn: vissen, kano\u00ebn en paardrijden.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"De kustlijn van Oregon\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_custom_heading text=\"Het \u00e9chte strandgevoel\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:3\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"6231\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Meer National Recreation Areas in West Amerika\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:6209,4663,5876\"][/vc_column][/vc_row]","post_title":"Oregon Dunes National Recreation Area","post_link":"https://www.heyusa.com/nl/oregon-dunes-national-recreation-area/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Oregon Dunes\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/05/Oregon-Dunes-duinen-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"National Recreation Area","post_tags":"Oregon","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1612950540814{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"2","%_edit_lock%":"1681201673:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"32","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"6230","%_yoast_wpseo_focuskw%":"Oregon Dunes National Recreation Area","%_yoast_wpseo_metadesc%":"De duinen van Oregon zijn een prachtig natuurgebied. Benieuwd wat je kunt doen in Oregon Dunes National Recreation Area?","%_yoast_wpseo_linkdex%":"70","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"855 US-101, Reedsport, OR 97467, Verenigde Staten","%_wpgmp_location_city%":"Reedsport","%_wpgmp_location_state%":"Oregon","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"43.7035323","%_wpgmp_metabox_longitude%":"-124.1059618","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_primary_category%":"111","%_yoast_indexnow_last_ping%":"1681201801","%_last_editor_used_jetpack%":"classic-editor","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"National Recreation Area","taxonomy=post_tag":"Oregon","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/parken.png"},"id":6226,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/parken.png","name":"Nationale Parken","id":"7","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Glen Canyon National Recreation Area","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Glen Canyon National Recreation Area\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/05/Glen-Canyon-NRA-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Glen Canyon National Recreation Area</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"4304 Bullfrog, Lake Powell, UT 84533, Verenigde Staten","location":{"lat":"37.3867256","city":"Lake Powell","state":"Utah","country":"Verenigde Staten","lng":"-110.8424257","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/glen-canyon-recreation-area/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Glen Canyon National Recreation Area\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Woeste woestijnlandschappen, diepe canyons en helder blauw water, dat is het Glen Canyon National Recreation Area in Arizona. Een goede bestemming inmiddels voor watersportliefhebbers, want tot het Glen Canyon National Recreation Area behoort ook Lake Powell. En varen tussen prachtige canyons op het een na grootste meer dat door de mens gemaakt is, is natuurlijk een ervaring op zich. Lees meer over het Glen Canyon National Recreation Area.[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Geen entree[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-location-arrow\"]3 km ten noorden van Page aan Highway 98 en vlakbij Highway 160[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612950540814{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Lake Powell en de canyon\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Een van de publiekstrekkers in het Glen Canyon National Recreation Area is Lake Powell. Het meer dat destijds gemaakt werd door de mens, biedt vele mogelijkheden tot vermaak. Met een kustlijn van ongeveer 3000 kilometer omringd door woestijnlandschappen van 4000km2 en canyons is het een unieke ervaring om over Lake Powell te varen. Of je dat nu per motorboot, kajak, catamaran, kajak of woonboot doet, indrukwekkend is het sowieso! Ook rondom de kustlijn van Lake Powell zijn genoeg activiteiten mogelijk. Daarnaast staat Glen Canyon bekend als een populaire bestemming om te wandelen en te fietsen.</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"De canyons van Glen Canyon National Recreation Area\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Ontdek de 96 verschillende canyons\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"6216\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Glen Canyon Dam Overlook\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een van de publiekstrekkers in het gebied is de Glen Canyon Dam. Net als de <a href=\"https://www.heyusa.com/nl/geen-categorie/the-vessel-bezoeken-in-hudson-yards/\" target=\"_blank\" rel=\"noopener\">Hoover Dam</a> in de buurt van Las Vegas, is deze dam gebouwd om het water in het gebied onder controle te houden en makkelijk elektriciteit te genereren. Door de komst van de dam werd Lake Powell gecre\u00eberd. Je kunt de machtige dam, die 216 meter hoog is, bezoeken en uitkijken over Lake Powell en de canyons via de Glen Canyon Dam Overlook. H\u00e9t moment voor een unieke foto van de Colorado River en omgeving.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Antelope Canyon\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De magische canyon van Antelope Canyon heb je vast al wel eens voorbij zien komen, deze behoort tot het Glen Canyon National Recreation Area. Wanneer je op het juiste moment door de canyon wandelt heb je kans om de prachtige lichtinval te bekijken. Je kunt de Lower Antelope Canyon en Upper Antelope Canyon bezoeken die zich in de buurt van Page bevinden. De Upper Antelope Canyon is de populairste van de twee en het makkelijkst te bezoeken. Ga mee met een tour om dit magische natuurwonder te bekijken.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Paradijs voor watersport\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_custom_heading text=\"Vaar tussen de prachtige canyons\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:3\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"6217\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Meer National Recreation Areas in West Amerika\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:4714,3014,4663,5876\"][/vc_column][/vc_row]","post_title":"Glen Canyon National Recreation Area","post_link":"https://www.heyusa.com/nl/glen-canyon-recreation-area/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Glen Canyon National Recreation Area\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/05/Glen-Canyon-NRA-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Natuur","post_tags":"Arizona","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1612950540814{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1676373666:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"32","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"6215","%_yoast_wpseo_focuskw%":"Glen Canyon National Recreation Area","%_yoast_wpseo_metadesc%":"Het Glen Canyon National Recreation Area en Lake Powell zijn niet te missen bezienswaardigheden in Arizona. Tips voor Glen Canyon en Lake Powell.","%_yoast_wpseo_linkdex%":"72","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"4304 Bullfrog, Lake Powell, UT 84533, Verenigde Staten","%_wpgmp_location_city%":"Lake Powell","%_wpgmp_location_state%":"Utah","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"37.3867256","%_wpgmp_metabox_longitude%":"-110.8424257","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_primary_category%":"32","%_yoast_indexnow_last_ping%":"1677015281","taxonomy=category":"Natuur","taxonomy=post_tag":"Arizona","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/parken.png"},"id":6209,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/parken.png","name":"Nationale Parken","id":"7","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Made Hotel","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Een hotelkamer in het Made Hotel in New York City\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/05/made-hotel-newyorkcity-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Made Hotel</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"44 W 29th St, New York, NY 10001, Verenigde Staten","location":{"lat":"40.7461759","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.9895245","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/overnachten-in-new-york-city/made-hotel/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Ontzettend gaaf boutique hotel in New York\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][ultimate_heading main_heading=\"44 W 29th Street, Manhattan, New York City\" heading_tag=\"div\" main_heading_font_family=\"font_family:Oswald|font_call:Oswald\" main_heading_font_size=\"desktop:30px;\" main_heading_line_height=\"desktop:35px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f\u2b50\ufe0f</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Made Hotel\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][ultimate_heading main_heading=\"$$$$\" main_heading_color=\"#c59c4d\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Als je op zoek bent naar een cool hotel in New York met een unieke urban boutique uitstraling, dan is het Made hotel in <a href=\"https://www.heyusa.com/nl/new-york/midtown-manhattan/\">Midtown Manhattan</a> gegarandeerd een hit. Het hotel heeft een grote instagram-coolness factor, net zoals het nabijgelegen Ace Hotel. Je vind hier een hippe koffiebar, co-working space, restaurant, bar en een rooftop bar met dj\u2019s en skyline uitzichten. Er zijn 108 kamers die vari\u00ebren in grootte en met industri\u00eble invloeden zijn ingericht.<span class=\"Apple-converted-space\">\u00a0</span>[/vc_column_text][ultimate_heading main_heading=\"Geselecteerd door Hey!USA\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_font_size=\"desktop:20px;\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]Het Made Hotel is door Hey!USA geselecteerd omdat je verblijf verder gaat dan enkel een kamer met een goed bed. De uitstraling van het hotel is gewoon #wow en je voelt je net een celebrity. In het hotel vind je 'Paper', het inpandige koffiecaf\u00e9 met zeer goede koffie. Je kunt gezellig tafelen in het Spaanse tapasrestaurant '<a href=\"https://www.debajonyc.com\" target=\"_blank\" rel=\"noopener\">Debajo</a>' en in de rooftopbar 'Good Behaviour' zijn regelmatig coole feestjes.[/vc_column_text][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fmade.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dheyusa_website|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][thb_image_slider lightbox=\"mfp-gallery\" thb_equal_height=\"true\" autoplay=\"true\" images=\"6157,6156,6155,6154,6153,6152,6146\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"6155\" img_size=\"large\" add_caption=\"yes\" style=\"vc_box_shadow_3d\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Populaire faciliteiten\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Het Made Hotel bevindt zich op ongeveer 600 meter van Macy's, op 550 meter van Madison Square Garden en 600 meter van het Empire State Building.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" list_content=\"Toplocatie\"][thb_iconlist icon=\"fas fa-wifi\" list_content=\"Gratis WiFi\"][thb_iconlist icon=\"fas fa-utensils\" list_content=\"Restaurant\"][thb_iconlist icon=\"fas fa-glass-cheers\" list_content=\"Bar\"][thb_iconlist icon=\"fas fa-concierge-bell\" list_content=\"Roomservice\"][thb_iconlist icon=\"fas fa-bed\" list_content=\"Comfortabele bedden\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek een kamer\" btn_link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fus%2Fmade.en.html%3Faid%3D7958498%26no_rooms%3D1%26group_adults%3D2%26label%3Dheyusa_website|title:Boek%20een%20kamer|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Andere hotels in New York City:\" main_heading_color=\"#b34a4c\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"25px\"][thb_postgrid style=\"style4\" columns=\"4\" source=\"size:8|post_type:post|categories:109\"][/vc_column][/vc_row]","post_title":"Made Hotel","post_link":"https://www.heyusa.com/nl/overnachten-in-new-york-city/made-hotel/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Een hotelkamer in het Made Hotel in New York City\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/05/made-hotel-newyorkcity-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Overnachten in New York City","post_tags":"","%inline_featured_image%":"0","%_edit_lock%":"1669738501:1","%_edit_last%":"1","%_yoast_wpseo_primary_category%":"109","%_thumbnail_id%":"6146","%_hide_featured%":null,"%_wpgmp_location_address%":"44 W 29th St, New York, NY 10001, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7461759","%_wpgmp_metabox_longitude%":"-73.9895245","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"13\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%post-primary-category%":"auto","%featured_image_override%":"off","%standard-featured-credit%":"Made Hotel New York","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_focuskw%":"made hotel","%_yoast_wpseo_metadesc%":"Made Hotel in New York City is een ontzettend cool, urban boutique hotel nabij Times Square en Madison Square.","%_yoast_wpseo_linkdex%":"61","%_yoast_indexnow_last_ping%":"1677015283","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Overnachten in New York City","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png"},"id":6145,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png","name":"Hotels","id":"13","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Rattlesnake Recreation Area","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rattlesnake Recreation Area\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/05/Rattlesnake-recreation-area-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Rattlesnake Recreation Area</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Rattlesnake Dr, Missoula, MT 59802, Verenigde Staten","location":{"lat":"46.966419","city":"Missoula","state":"Montana","country":"Verenigde Staten","lng":"-113.871773","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/rattlesnake-recreation-area-montana/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Rattlesnake Recreation Area\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In Montana vind je het Rattlesnake Recreation Area en Wilderness. Opgericht door het Congress in 1980, is het een toeristische bestemming geworden voor toeristen die Missoula bezoeken, het stadje dat op ongeveer 6 kilometer ligt. Het gebied heeft vele hiking trails waar zowel wandelaars, mountainbikers, ski\u00ebrs en paardrijders gebruik van maken. In het gebied leven wilde dieren als elanden, herten, berggeiten en grizzlies.[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Geen entree[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]24 Fort Missoula Road, Missoula[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612950540814{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"De naam Rattlesnake\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Over hoe Rattlesnake Creek, de rivier die door het gebied stroomde, zijn naam kreeg, gaan verschillende verhalen rond. De eerste variant gaat over een man die gebeten werd door een ratelslang en stierf tijdens het verzamelen van brandhout in de kreek in de 19e eeuw. De andere variant komt van het Salish woord: \"Kehi-oo-le\" dat ratelslang betekent. Overigens komen er helemaal geen ratelslangen voor in het gebied.</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Missoula Montana\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Uitvalsbasis voor het Rattlesnake Recreation Area\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"5887\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Missoula - de nabij gelegen stad\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het plaatsje Missoula in Montana ligt het dichtst bij het Rattlesnake Recreation Area. Het is een populaire woonplaats en een van de snelst groeiende steden in Amerika. Omringd door bergen en natuur is het een perfecte uitvalsbasis voor natuurliefhebbers. Mount Sentinel ligt praktisch om de hoek en ook de wildernis van Rattlesnake is goed te bereiken. Andere bezienswaardigheden in de omgeving zijn National Bison Range Refuge, Lolo Hot Springs en Garnet Ghost Town. Het is dus een stad waar je een paar dagen kunt verblijven om te genieten van de voorzieningen van de stad en de natuur om de hoek hebt.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Tips voor Rattlesnake Recreation Area\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Rattlesnake Recreation Area in Montana kun je het beste bezoeken vanuit het stadje Missoula. Je vindt er prachtige meren, berg-kammen en toppen en hellingen met kliffen. Het park varieert in hoogte, aan de zuidkant zijn de laagste bergen te vinden. Het recreatiegebied is geschikt voor wandelaars, mountainbikers, bouldering en in de winter kun je er ski\u00ebn. Dat maakt het Rattlesnake Recreation Area geschikt voor alle seizoenen. Faciliteiten zijn niet overal in het gebied te vinden. Zo kun je nergens drinkwater vinden en wc's zijn alleen te vinden bij de hoofdtrail bij Rattlesnake (#515).\r\n\r\nIn het gebied vind je een aantal hoge bergen, de hoogste is de McLeod Peak die ruim 2500 meter hoog is. Wil je hiken in het gebied? Dat kan prima ondanks dat je te maken krijgt met hoogteverschillen. Er is meer dan 100 kilometer aan wandelpaden die je kunt volgen. De meeste trails starten in Missoula. Hier kun je \u00e9\u00e9n van de acht offici\u00eble trails volgen. Sommige trails zijn best pittig vanwege de bergen in het gebied. Je deelt soms het pad met mountainbikers en paardrijders.\r\n\r\nEen van de populairste dag hikes is de Rattlesnake Trail. Een wandelpad van totaal 54,6 kilometer met onderweg allerlei zij-wandelpaden die je kunt nemen. Tijdens het wandelen kun je beverdammen spotten.\r\n\r\nRattlesnake Area en Wilderness ligt in de buurt van <a href=\"https://www.heyusa.com/nl/glacier-national-park/\" target=\"_blank\" rel=\"noopener\">Glacier National Park</a> en zijn te combineren tijdens een roadtrip.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Bergtoppen van Rattlesnake Mountains\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_custom_heading text=\"Hiken tussen de bergtoppen\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:3\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"5888\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Meer National Recreation Areas in West Amerika\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:4714,3014,6209,4663\"][/vc_column][/vc_row]","post_title":"Rattlesnake Recreation Area","post_link":"https://www.heyusa.com/nl/rattlesnake-recreation-area-montana/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rattlesnake Recreation Area\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/05/Rattlesnake-recreation-area-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Nationale Parken","post_tags":"Montana","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1612950540814{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1622198631:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"32","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"5882","%_yoast_wpseo_focuskw%":"Rattlesnake Recreation Area Montana","%_yoast_wpseo_metadesc%":"De Rattlesnake Mountains in Montana staan bekend om de prachtige bergtoppen. Benieuwd wat je kunt doen in Rattlesnake Recreation Area?","%_yoast_wpseo_linkdex%":"64","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"Rattlesnake Dr, Missoula, MT 59802, Verenigde Staten","%_wpgmp_location_city%":"Missoula","%_wpgmp_location_state%":"Montana","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"46.966419","%_wpgmp_metabox_longitude%":"-113.871773","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_primary_category%":"32","%_yoast_indexnow_last_ping%":"1677015291","taxonomy=category":"Nationale Parken","taxonomy=post_tag":"Montana","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/parken.png"},"id":5876,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/parken.png","name":"Nationale Parken","id":"7","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Griffith Observatory Los Angeles","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Griffith Observatory\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/04/Griffith-uitzicht-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Griffith Observatory Los Angeles</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"2800 E Observatory Rd, Los Angeles, CA 90027, Verenigde Staten","location":{"lat":"34.1184341","city":"Los Angeles","state":"California","country":"Verenigde Staten","lng":"-118.3003935","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/griffith-observatory-los-angeles/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"<p>[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text]<strong>Hoewel het Griffith Observatory in Los Angeles vaak bekend staat als een goede plek om uit te kijken op het Hollywood Sign en Los Angeles, heeft het meer te bieden. Het is een sterrenwacht op de berg genaamd Hollywood. Het gebouw komt je vast bekend voor, het is namelijk decor geweest in vele films en series. Tips voor je bezoek aan het Griffith Observatory in Los Angeles.</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"4730 Crystal Springs Dr.\"][vc_empty_space height=\"25px\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Gratis museum in Los Angeles!\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_column_text]</p>\r\n<p style=\"text-align: center;\">In 1896 doneerde kolonel Griffith J. Griffith het land aan de stad Los Angeles. Door middel van een testament schonk hij de stad een fonds om een observatorium, sterrenwacht en ruimtes voor tentoonstellingen te bouwen.\u00a0 De wens van Griffith was een museum voor iedereen, er wordt dan ook geen entreegeld gevraagd. Parkeren is echter niet kosteloos. Daarnaast heb je vanaf het Griffith Observatory een prachtig uitzicht over de stad als er weinig smog hangt. Ook het <a href=\"https://www.heyusa.com/nl/los-angeles/hollywood/\" target=\"_blank\" rel=\"noopener\">Hollywood</a> Sign is goed te zien vanaf hier.</p>\r\n<p>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Griffith Observatory\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Een van de aanraders in Los Angeles\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"5154\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Wat mag je niet missen in het Griffith Observatory\" font_container=\"tag:h2|font_size:50|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"5158\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Planetarium\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Onder de grote koepel van het Griffith Observatory bevindt zich een planetarium. Het bevat een Zeiss projector en een tentoonstelling hoe de mensheid al die jaren de lucht/ruimte heeft bekeken. In het theater wordt een planetarium show opgevoerd, een programma van 30 minuten dat je alles verteld over de sterrenwacht. Voor deze show dienen <a href=\"https://griffithobservatory.org/exhibits/samuel-oschin-planetarium/\" target=\"_blank\" rel=\"noopener\">kaarten gekocht</a> te worden.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"5155\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Griffith Park\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Rondom het Griffith Observatory vind je het Griffith Park. Vanaf hier heb je een prachtig uitzicht over de stad Los Angeles wanneer er niet te veel smog is. Naast het Griffith Observatory bevinden zich nog meer bezienswaardigheden in het Griffith Park. Zo kun je een combi bezoek maken met de Los Angeles Zoo, het Hollywood Sign en The Autry Museum of the American West.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"5157\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Telescopen in het Griffith Observatory\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Het Griffith Observatory is een van de belangrijkste observatoria van de wereld. Dit komt vooral door de mogelijkheid om gebruik te maken van de beschikbare openbare telescopen. Deze telescopen zijn dag en nacht gratis voor het publiek wanneer het gebouw open is. Kom meer te weten over de sterrenwacht via een van de telescopen van het Griffith Observatory.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Santa Monica Pier\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"De beroemdste pier van LA\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fsanta-monica-pier-los-angeles%2F|title:Santa%20Monica%20Pier\" btn_align=\"ubtn-center\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"4972\"][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]</p>\r\n","post_title":"Griffith Observatory Los Angeles","post_link":"https://www.heyusa.com/nl/griffith-observatory-los-angeles/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Griffith Observatory\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/04/Griffith-uitzicht-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea Los Angeles","post_tags":"","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1667313084:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Griffith Observatory Los Angeles","%_yoast_wpseo_metadesc%":"Een van de uitkijkpunten op het Hollywood Sign is het Griffith Observatory Los Angeles. Tips voor je bezoek aan Griffith Observatory LA.","%_yoast_wpseo_linkdex%":"79","%_wpgmp_location_address%":"2800 E Observatory Rd, Los Angeles, CA 90027, Verenigde Staten","%_wpgmp_location_city%":"Los Angeles","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"34.1184341","%_wpgmp_metabox_longitude%":"-118.3003935","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"54","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_thumbnail_id%":"5156","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1677015295","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Musea Los Angeles","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":5149,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Natural History Museum Los Angeles","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Natural History Museum Los Angeles\" width=\"300\" height=\"199\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/04/natural-history-museum-losangeles-300x199.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Natural History Museum Los Angeles</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"900 W Exposition Blvd, Los Angeles, CA 90037, Verenigde Staten","location":{"lat":"34.01722009999999","city":"Los Angeles","state":"California","country":"Verenigde Staten","lng":"-118.2887185","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/natural-history-museum-los-angeles/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"<p>[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Het Natural History Museum in Los Angeles\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]<strong>In Los Angeles vind je het Natural History Museum, het grootste natuurlijke en historisch museum in het westen van Amerika. Meer dan 4,5 miljard jaar aan geschiedenis is er te vinden in het museum. Er valt genoeg te kijken in het museum, want er zijn meer dan 35 miljoen exemplaren en artefacten. Tips voor je bezoek aan het Natural History Museum.\u00a0</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"900 W Exposition Blvd\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek je tickets\" btn_link=\"url:https%3A%2F%2Fnhm.org|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Verschillende musea onder 1 organisatie\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]</p>\r\n<p style=\"text-align: center;\">In Exposition Park in LA werd het Natural History Museum geopend in 1913, destijds onder de naam The Museum of History, Science and Art. Het kreeg de oorspronkelijke naam na een splitsing met het Los Angeles County Museum of Art (LACMA) in 1961. In het museum zijn drie verdiepingen met permanente tentoonstellingen. De exposities waar skeletten van dieren zijn opgesteld zijn verreweg het populairst in het NHM. De LA Brea Tar en The Hart Museum maken tegenwoordig ook deel uit van The Natural History Museum.</p>\r\n<p>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen in het Natural History Museum in Los Angeles\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"5145\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Dinosaur Hall\" heading_tag=\"h3\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Ronddwalen tussen indrukwekkende skeletten van dinosaurussen kan in de Dinosaur Hall van het museum. Bij deze expositie vind je een twintigtal skeletten van de grootste en meest interessante dinosaurussen die geleefd hebben op aarde.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"7515\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Nature Lab - LA Wildside\" heading_tag=\"h3\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]Hoewel Los Angeles een enorm grote stad is met veel inwoners en beton, heeft het toch een grote biodiversiteit qua natuur. Ontdek de wilde planten en dieren die leven in de omgeving van de stad. Bekijk de lokale spinnen, slangen, ratten en kikkers die je tegen kunt komen in LA.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"5144\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Hall of Birds\" heading_tag=\"h3\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]In Los Angeles zijn meer dan 400 verschillende vogelsoorten te vinden. In het museum kom je meer te weten over de specimen en nestgaten van de vogels die voorkomen in de stad. Bekijk bijvoorbeeld het enorme nest van een condor in de expositie Hall of Birds.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Ook leuk om te doen in Los Angeles\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][thb_postgrid columns=\"4\" source=\"post_type:post|by_id:5149,5107,4989,7537\"][/vc_column][/vc_row]</p>\r\n","post_title":"Natural History Museum Los Angeles","post_link":"https://www.heyusa.com/nl/natural-history-museum-los-angeles/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Natural History Museum Los Angeles\" width=\"300\" height=\"199\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/04/natural-history-museum-losangeles-300x199.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea Los Angeles","post_tags":"","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1667313190:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Natural History Museum Los Angeles","%_yoast_wpseo_metadesc%":"In het Natural History Museum in Los Angeles vind je alles over natuur en historie. Tips voor je bezoek aan het Natural History Museum in LA","%_yoast_wpseo_linkdex%":"72","%_wpgmp_location_address%":"900 W Exposition Blvd, Los Angeles, CA 90037, Verenigde Staten","%_wpgmp_location_city%":"Los Angeles","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"34.01722009999999","%_wpgmp_metabox_longitude%":"-118.2887185","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"54","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_thumbnail_id%":"7515","%standard-featured-credit%":"Credit: Courtesy of the Natural History Museum of L.A. County (NHM)","%_yoast_indexnow_last_ping%":"1677015299","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Musea Los Angeles","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":5138,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Hollywood Museum Los Angeles","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hollywood\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/03/Hollywood-Museum-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Hollywood Museum Los Angeles</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1660 N Highland Ave, Hollywood, CA 90028, Verenigde Staten","location":{"lat":"34.1010804","city":"Los Angeles","state":"California","country":"Verenigde Staten","lng":"-118.338528","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/hollywood-museum-los-angeles/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"<p>[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Hollywood Museum in Los Angeles\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]<strong>Het Hollywood Museum in Los Angeles herbergt alles wat maar met Hollywood te maken heeft. In het oude Max Factor gebouw vind je meer dan 10.000 attributen die gebruikt zijn in films en televisieseries. Ontdek meer dan 100 jaar filmgeschiedenis in het Hollywood Museum in Los Angeles.</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"1660 N Highland Ave\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek je tickets\" btn_link=\"url:http%3A%2F%2Fthehollywoodmuseum.mybigcommerce.com%2Fbuy-tickets-for-the-hollywood-museum-here%2F%3Fsort%3Dpriceasc|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Geschiedenis van Hollywod &amp; Walk of Fame\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]</p>\r\n<p style=\"text-align: center;\">Met meer dan 10.000 objecten krijg je in het Hollywood Museum een goede indruk van films en series die de afgelopen 100 jaar zijn opgenomen in Hollywood. Je vindt er de box handschoenen van Rocky, de beroemde jurk van Marilyn Monroe, het Superman pak en nog vele andere bekende attributen. Je waant je tussen de herkenbare attributen die filmsterren gebruikten, hoe gaaf is dat?</p>\r\n<p>[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"250px\"][ultimate_heading main_heading=\"Hollywood Museum\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Een must voor filmliefhebbers\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"250px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"5126\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Wat mag je niet missen in het Hollywood Museum\" font_container=\"tag:h2|font_size:50|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"5127\" img_size=\"300x300\" alignment=\"center\" style=\"vc_box_circle_2\"][ultimate_heading main_heading=\"The Dungeon of Doom\" heading_tag=\"h3\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Durf jij het aan om in de kelder van het museum te komen? In de kelder vind je allerlei attributen die met enge films te maken hebben. Wandel door de gevangenisingang van The Silence of The Lambs en bekijk de cel van Hannibal Lecter. Of bekijk de rekwisieten van The Walking Dead. Allerlei culthelden uit enge films vind je in de kelder van het Hollywood Museum.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"5129\" img_size=\"300x300\" alignment=\"center\" style=\"vc_box_circle_2\"][ultimate_heading main_heading=\"Harry Potter\" heading_tag=\"h3\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Alle Harry Potter fans kunnen in het Hollywood Museum hun hart ophalen. Er liggen in het museum diverse attributen die gebuikt zijn in de films. Bekijk de kleding die Harry Potter droeg in de film, de bezem of natuurlijk de toverstokken die hij gebruikte.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"5128\" img_size=\"300x300\" alignment=\"center\" style=\"vc_box_circle_2\"][ultimate_heading main_heading=\"Superhero Legends\" heading_tag=\"h3\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Spot al je superhelden in \u00e9\u00e9n ruimte! Wat dacht je van de pakken die gebruikt werden voor Batgirl, Batman, Superman of Wonder Woman. Niet alleen de superhelden maar ook de tegenstanders van ze, staan in 1 kamer. Je ziet superhelden voorbij komen uit meer dan 50 jaar geschiedenis.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"250px\"][ultimate_heading main_heading=\"Santa Monica Pier\" heading_tag=\"p\" main_heading_color=\"#ffffff\" sub_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Arvo|font_call:Arvo|variant:700italic\" main_heading_line_height=\"desktop:45px;\" sub_heading_font_family=\"font_family:Rubik Mono One|font_call:Rubik+Mono+One\" sub_heading_font_size=\"desktop:20px;\" main_heading_style=\"font-style:italic;font-weight:700;\"]Icoon van LA[/ultimate_heading][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fsanta-monica-pier-los-angeles%2F|title:Santa%20Monica%20Pier%20Los%20Angeles\" btn_align=\"ubtn-center\" btn_size=\"ubtn-small\" btn_bg_color=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_shadow=\"shd-bottom\" btn_shadow_color=\"#0a0a0a\" btn_shadow_size=\"5\" btn_font_family=\"font_family:Rubik Mono One|font_call:Rubik+Mono+One\" btn_font_size=\"desktop:18px;\"][vc_empty_space height=\"250px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"4972\"][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]</p>\r\n","post_title":"Hollywood Museum Los Angeles","post_link":"https://www.heyusa.com/nl/hollywood-museum-los-angeles/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hollywood\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/03/Hollywood-Museum-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea Los Angeles","post_tags":"","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1667313233:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Hollywood Museum Los Angeles","%_yoast_wpseo_metadesc%":"In het Hollywood Museum in Los Angeles vind je alles over Hollywood. Tips voor je bezoek aan het Hollywood Museum in Los Angeles.","%_yoast_wpseo_linkdex%":"72","%_wpgmp_location_address%":"1660 N Highland Ave, Hollywood, CA 90028, Verenigde Staten","%_wpgmp_location_city%":"Los Angeles","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"34.1010804","%_wpgmp_metabox_longitude%":"-118.338528","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"54","%_thumbnail_id%":"5010","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1677015301","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Musea Los Angeles","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":5121,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Honkbalwedstrijd van de Los Angeles Dodgers bijwonen","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Dodger Stadium\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/03/Dodger-Stadium-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Honkbalwedstrijd van de Los Angeles Dodgers bijwonen</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1000 Vin Scully Ave, Los Angeles, CA 90012, Verenigde Staten","location":{"lat":"34.073851","city":"Los Angeles","state":"California","country":"Verenigde Staten","lng":"-118.2399583","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/los-angeles-dodgers/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Honkbalwedstrijd van de Los Angeles Dodgers bijwonen\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Als sportliefhebber is het een super toffe ervaring om een sportwedstrijd bij te wonen in Amerika. Ook in Los Angeles spelen er clubs op het hoogste niveau. Wat dacht je van het de honkballers van de LA Dodgers. De wedstrijden spelen ze in het Dodger Stadium in Los Angeles. Een unieke ervaring om een sportwedstrijd mee te maken in Los Angeles en ook nog eens in een prachtig stadion!</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]Seizoen loopt van april tot oktober[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Tussen de $10 en $105[/ultimate_icon_list_item][/ultimate_icon_list][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.mlb.com%2Fdodgers%2Ftickets|title:Bestel%20je%20tickets\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#000000\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612789513968{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Over Los Angeles Dodgers\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">De honkbalclub uit Los Angeles speelt onder de naam Los Angeles Dodgers. Dit is overigens niet altijd het geval geweest. Ooit begon de club namelijk in Brooklyn <a href=\"https://www.heyusa.com/nl/new-york-yankees-wedstrijd/\" target=\"_blank\" rel=\"noopener\">New York</a> als de Brooklyn Dodgers. In 1958 verhuisde de club, na 68 seizoenen in Brooklyn, naar Los Angeles. Vanaf 1962 namen ze intrek in het Dodger Stadium en boekten ze onmiddellijk succes. Ook in 2020 wonnen de Dodgers de World Series.</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Dodger Stadium\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:1px;\"][/ultimate_heading][vc_custom_heading text=\"De thuisbasis van The Los Angeles Dodgers\" font_container=\"tag:div|font_size:35|text_align:center|color:%23ffffff|line_height:3\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"5113\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Dodger Stadium\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Dodger Stadium ligt in de wijk Elysian Park in Los Angeles. Het werd geopend om 10 april 1962 en is de thuisbasis van de LA Dodgers sindsdien. Het is het oudste honkbalveld ten westen van de rivier de Mississippi, in Bosten (Fenway Park) en Chicago (Wrigley Field) vind je de twee oudste stadions van Amerika. Wanneer je kijkt naar het aantal zitplaatsen, is het Dodger Stadium de grootste ter wereld. Naast honkbal worden er af en toe ook voetbalwedstrijden gespeeld. In 2013 was het thuisbasis voor een voetbaltoernooi met Juventus. Everton, Real Madrid en de Los Angeles Galaxy.[/vc_column_text][vc_custom_heading text=\"Tickets voor The LA Dodgers\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Tickets voor de Yankees heb je al vanaf $12, maar kunnen gerust ook enkele honderden dollars kosten. Een redelijke prijs is tussen de $35 en $65 voor een kaartje. Het mooiste zicht heb je in de Field Box secties. Lukt het niet om hier een ticket te scoren, dan zijn de secties 101-136 ook een optie. Ben je met een familie in Los Angeles? Dan is de beste optie de 301-315 sectie. Wil je alleen sfeerproeven, dan is het prima om bovenin te zitten en een goedkoper kaartje te scoren.[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.mlb.com%2Fdodgers%2Ftickets\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#000000\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"1/2\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Ook al heb je niet zoveel met honkbal, een bezoek aan The LA Dodgers is een echter Amerikaanse ervaring en ook dan de moeite waard\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>100 Vin Scully Avenue</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>April t/m oktober</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-subway\"]<strong>Union Station - Dodger Stadium Express</strong>[/ultimate_icon_list_item][/ultimate_icon_list][vc_custom_heading text=\"Hoe kom je bij het Dodger Stadium?\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_column_text]Wanneer je The LA Dodgers gaat bezoeken in het Dodger Stadium, kun je het beste direct een parkeerticket kopen als je met de auto komt. Wil je liever de auto laten staan? Pak dan vanaf Union Station de Dodger Stadium Express. Deze is vrij toegankelijk voor iedereen die een kaartje heeft. Bij de taxi zone van Union Station vertrekt de Dodger Stadium Express. Hij rijdt iedere 10 minuten en start 90 minuten voor de wedstrijd. Na de wedstrijd vertrekt de de Dodger Stadium Express tot 45 minuten na afloop.[/vc_column_text][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"5/6\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Natuurlijk kan een bezoek aan de shop niet ontbreken wanneer je een wedstrijd bezoekt\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Los Angeles Dodgers in actie\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_custom_heading text=\"Unieke ervaring in Amerika\" font_container=\"tag:div|font_size:25|text_align:center|color:%23ffffff|line_height:3\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"5115\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Los Angeles\" font_container=\"tag:div|font_size:50|text_align:center|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"by_id:4967,5162,5149,2299\"][/vc_column][/vc_row]","post_title":"Honkbalwedstrijd van de Los Angeles Dodgers bijwonen","post_link":"https://www.heyusa.com/nl/los-angeles-dodgers/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Dodger Stadium\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/03/Dodger-Stadium-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Los Angeles","post_tags":"","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1612789513968{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}","%_edit_last%":"1","%_edit_lock%":"1632831421:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"52","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_yoast_wpseo_focuskw%":"Honkbalwedstrijd van de Los Angeles Dodgers bijwonen","%_yoast_wpseo_title%":"Honkbalwedstrijd van de Los Angeles Dodgers bijwonen %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Sportliefhebber? Dan moet je echt een honkbalwedstrijd van de Los Angeles Dodgers bijwonen in het Dodger Stadium in LA.","%_yoast_wpseo_linkdex%":"64","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_thumbnail_id%":"5114","%_wpgmp_location_address%":"1000 Vin Scully Ave, Los Angeles, CA 90012, Verenigde Staten","%_wpgmp_location_city%":"Los Angeles","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"34.073851","%_wpgmp_metabox_longitude%":"-118.2399583","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_primary_category%":"52","%_yoast_indexnow_last_ping%":"1677015303","taxonomy=category":"Bezienswaardigheden Los Angeles","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":5107,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Santa Monica Pier Los Angeles","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Santa Monica Pier Los Angeles\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/03/Santa-Monica-Pier3-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Santa Monica Pier Los Angeles</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"200 Santa Monica Pier, Santa Monica, CA 90401, Verenigde Staten","location":{"lat":"34.00992149999999","city":"Santa Monica","state":"California","country":"Verenigde Staten","lng":"-118.4960063","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/santa-monica-pier-los-angeles/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Santa Monica Pier Los Angeles\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">De Santa Monica Pier in Los Angeles is een van de belangrijkste bezienswaardigheden van de stad. Je vindt de pier in de wijk <a href=\"https://www.heyusa.com/nl/santa-monica/\" target=\"_blank\" rel=\"noopener\">Santa Monica</a>. De Santa Monica Pier loopt 300 meter de Stille Oceaan in en op de pier vind je allemaal toeristische attracties. Ook staat er het bord dat het einde van <a href=\"https://www.heyusa.com/nl/roadtrip-nationale-parken-route-66/\" target=\"_blank\" rel=\"noopener\">Route 66</a> markeert.\r\n</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Gratis[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612950540814{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Weetjes over de Santa Monica Pier\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Wist je dat de huidige Santa Monica Pier bestaat uit twee samengevoegde pieren? Lange tijd hadden beide pieren, die ook nog eens verschillende eigenaren hadden, een ander doel. De een voor de afvoer van rioolbuizen, de ander was een attractiepark. In 1938 werden beide pieren met elkaar verbonden door een brug. De jaren erna waren er verschillende plannen voor de pier. De komst van een hotel leidde tot veel protesten waardoor afgezien werd van de bouw. Na een aantal stormen te hebben getrotseerd, overigens kwam de pier er niet helemaal ongeschonden uit, werd in 1996 Pacific Park geopend.</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Pacific Park\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Durf jij het aan?\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"4971\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Santa Monica Pier in films\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">De Santa Monica Pier was al in vele films het decor. De meest bekende film waarin de Pier voorkwam was Forrest Gump uit 1994. Ook in televisieseries kwam de Pier regelmatig voorbij. Wat dacht je van de serie Baywatch of Star Trek Voyager.\r\n</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Wat te doen op de Santa Monica Pier?\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Op de Santa Monica Pier kun je allerlei activiteiten ondernemen. Van shoppen, lekker eten tot talloze attracties, je kunt je best een middag vermaken op de pier. De meeste bezoekers komen voor <a href=\"https://pacpark.com/\" target=\"_blank\" rel=\"noopener\">Pacific Park</a>, een klein attractiepark met een achtbaan, reuzenrad en diverse kermisattracties. Natuurlijk mag je het bord 'End of the trail' van Route 66 ook niet missen! Overigens kun je de Pier gratis bezoeken, je betaalt per attractie een bepaald bedrag.</span>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Enjoy the view!\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_custom_heading text=\"De Santa Monica Pier in het donker\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:3\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"4947\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Los Angeles\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:7537,5149,5107,2299,5162\"][/vc_column][/vc_row]","post_title":"Santa Monica Pier Los Angeles","post_link":"https://www.heyusa.com/nl/santa-monica-pier-los-angeles/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Santa Monica Pier Los Angeles\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/03/Santa-Monica-Pier3-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Los Angeles","post_tags":"","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1612950540814{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1710931693:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"52","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"4972","%_yoast_wpseo_focuskw%":"Santa Monica Pier Los Angeles","%_yoast_wpseo_metadesc%":"De Santa Monica Pier in Los Angeles behoort tot een van de populairste bezienswaardigheden. Benieuwd wat je kunt doen bij de Santa Monica Pier","%_yoast_wpseo_linkdex%":"72","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"200 Santa Monica Pier, Santa Monica, CA 90401, Verenigde Staten","%_wpgmp_location_city%":"Santa Monica","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"34.00992149999999","%_wpgmp_metabox_longitude%":"-118.4960063","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_primary_category%":"52","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1677015310","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Bezienswaardigheden Los Angeles","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":4967,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Sequoia en Kings Canyon National Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sequoia en Kings Canyon NP\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/03/Kings-en-Sequoia-NP1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Sequoia en Kings Canyon National Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Californi\u00eb, Verenigde Staten","location":{"lat":"36.48636679999999","state":"Californi\u00eb","country":"Verenigde Staten","lng":"-118.5657516","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/sequoia-kings-canyon-national-park/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Sequoia en Kings Canyon National Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het tweede nationale park van Amerika, Yellowstone NP was de eerste, is Sequoia National Park. In het zuidelijke deel van de <a href=\"https://www.heyusa.com/nl/sierra-nevada-californie/\">Sierra Nevada</a> in Californi\u00eb vind je het park dat bekend staat om de reuzenbomen, Sequoia bomen. Aan de zuidkant van het park vind je Kings Canyon National Park, door de nationale park service worden deze twee parken gezien als \u00e9\u00e9n geheel. Benieuwd wat je naast de reuzenbomen niet mag missen in deze twee parken? Tips voor je bezoek aan Sequoia en Kings Canyon National Park.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]327 kilometer vanaf Los Angeles[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">3500 km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-paw\"]250 verschillende soorten dieren[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-leaf\"]<span class=\"LrzXr kno-fv\">1500 verschillende soorten planten</span>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Ongerepte nationale parken\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Sequoia en Kings Canyon National Park behoren vandaag de dag tot de meeste ongerepte parken van Amerika. 90% van het gebied is alleen te voet te bereiken, geen van de 2600 meren in de parken zijn niet eens met auto te bezoeken. Gelukkig kun je wel in een deel van de parken met de auto komen, de parken zijn met elkaar verbonden door twee doorgaande wegen. Onderweg zie je reusachtige bomen en canyons en heb je de mogelijkheid om te stoppen bij verschillende bezienswaardigheden. In Sequoia NP ligt de hoogste berg van de 48 aangrenzende staten van Amerika, Mount Whitney is 4421 meter hoog.</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"General Sherman Tree\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"p\" text_align=\"center\" heading=\"Krijg jij je armen om een 9 meter brede Sequoia?\" font_size=\"45\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"4842\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Facts Sequoia en Kings Canyon National Park\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het terrein van de zuidelijke Sierra Nevada was lange tijd het leefgebied van de Monache indianen. De goudkoorts in 1849 zorgde voor een einde aan hun traditionele leefwijze. Duizenden goudzoekers trokken het gebied in en verjaagden daarmee de Monache indianen. Na de goudzoekers volgden houthakkers en veehouders waardoor bomen gekapt werden en het vee de bergweiden kaal graasden. John Muir begon in 1870 protest te tekenen tegen het verwoesten van de natuur. Gelukkig werd het gebied in 1890 verklaard tot National Park en kon de natuur zijn gang weer gaan.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Hoogtepunten in Sequoia en Kings Canyon NP\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Tijdens je bezoek aan Sequoia en Kings Canyon NP mag je natuurlijk de reuzenbomen, ook wel sequoia's, niet missen. Giant Forest is de beste plek om deze te spotten. Daarbij is de General Sherman Tree de grootste van allemaal, zo'n 9 meter breed en meer dan 84 meter hoog. Andere hoogtepunten in het Sequoia NP zijn de Tunnel Log en Crystal Cave. In Kings Canyon NP mag je Grant Cove, de General Grant Tree en natuurlijk de Kings Canyon niet missen.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Overnachten in het Sequoia en Kings Canyon NP\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In Sequoia en Kings Canyon NP zijn vier lodges te vinden waarvan twee het hele jaar open zijn. De John Muir Lodge en Wuksachi Lodge zijn het hele jaar te boeken, de andere twee alleen in het hoogseizoen. Beiden zijn centraal gelegen, overigens wil het in de wintermaanden nog wel eens gebeuren dat sneeuwkettingen noodzakelijk zijn om de laatst genoemde lodge te bereiken. Er zijn ook een tweetal campings in het park. Als je met een RV reist, check dan van te voren de afmetingen omdat je niet overal kunt komen met een camper.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Beste reisperiode Sequoia en Kings Canyon NP\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Doordat er enorme hoogteverschillen zijn in het park, kan het weer verschillen per gebied. Over het algemeen is de zomerperiode het drukst, de temperaturen zijn dan ook het beste om het park te verkennen. In de herfst heb je de kans om een storm te treffen, langzaam beginnen faciliteiten te sluiten en het is de periode wanneer de eerste sneeuw valt. In de lente heb je kans dat je nog sneeuw treft waardoor je moet reizen met sneeuwkettingen.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Roaring River Falls\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"Korte wandeling in Kings Canyon\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"4843\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelingen &amp; trails\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]Hoewel een groot deel van het park ongerepte wildernis is, zijn er meer dan 1300 kilometer aan wandelpaden te vinden. De bekendste route in het park is de John Muir trail, een 350 kilometer lang wandelpad dat dwars door het park loopt en tevens onderdeel is van de Pacific Crest Trail. Gelukkig zijn er ook een boel korte routes die je kunt lopen. In een aantal gebieden zijn diverse trails uitgezet.[/vc_column_text][ultimate_heading main_heading=\"General Sherman Tree Trail\" heading_tag=\"h3\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]Een leuke optie voor een korte wandeling langs gigantische reuzenbomen is de General Sherman Tree Trail. Een wandeling van ongeveer 1,5 kilometer langs de General Sherman Tree, de grootste boom in het gebied en dwars door het bos met nog meer reusachtige sequoia's.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]24/7 en 365 dagen geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: zomer[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]7 daagse pas met auto of camper: $35[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-ticket\" content_font_size=\"desktop:16px;\"]$20 per persoon voor 1-7 dagen[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-location-arrow\" content_font_size=\"desktop:16px;\"]1300 kilometer aan wandelpaden[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_single_image image=\"19213\" img_size=\"full\" alignment=\"center\" onclick=\"link_image\"][vc_gallery gallery_type=\"thb-portfolio\" lightbox=\"mfp-gallery\" images=\"19214,19215,19216\" img_size=\"large\"][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Tunnel Log in Sequoia NP\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"Rijdend door Sequoia en Kings Canyon NP is al indrukwekkend\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"4844\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Meer nationale parken\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:4738,4714,4689,4792\"][/vc_column][/vc_row]","post_title":"Sequoia en Kings Canyon National Park","post_link":"https://www.heyusa.com/nl/sequoia-kings-canyon-national-park/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sequoia en Kings Canyon NP\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/03/Kings-en-Sequoia-NP1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Sequoia en Kings Canyon National Park","post_tags":"Californi\u00eb","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_lock%":"1709286961:1","%_edit_last%":"1","%_thumbnail_id%":"4841","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Sequoia en Kings Canyon National Park","%_yoast_wpseo_metadesc%":"Ongerepte wildernis in Californi\u00eb vind je in Sequoia en Kings Canyon National Park. Ontdek de reuzenbomen en canyons van Sequoia en Kings Canyon","%_yoast_wpseo_linkdex%":"72","%_wpgmp_location_address%":"Californi\u00eb, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Californi\u00eb","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"36.48636679999999","%_wpgmp_metabox_longitude%":"-118.5657516","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_primary_category%":"90","%_yoast_indexnow_last_ping%":"1709217309","%_last_editor_used_jetpack%":"classic-editor","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","taxonomy=category":"Sequoia en Kings Canyon National Park","taxonomy=post_tag":"Californi\u00eb","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""}},"id":4835,"infowindow_disable":false},{"source":"post","title":"De Hoover Dam in Nevada","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hoover Dam Nevada\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/03/Hoover-Dam1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">De Hoover Dam in Nevada</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Nevada 89005, Verenigde Staten","location":{"lat":"36.0160655","state":"Nevada","country":"Verenigde Staten","lng":"-114.7377325","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/hoover-dam-nevada/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"De Hoover Dam in Nevada\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Tussen 1931 en 1936 werd in Nevada de Hoover Dam gebouwd om de onvoorspelbare Colorado River te temmen. Ook werd de dam aangelegd om elektriciteit te leveren voor de woestijngebieden in de staten Nevada, Arizona en Californi\u00eb. Resultaat van de aanleg van de Hoover Dam is niet alleen een toeristische trekpleister, maar ook het ontstaan van Lake Mead.[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-arrows-v\"]221,40 meter hoog[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-building\"]379 meter lengte[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-calendar\"]Gesloten met Thanksgiving en Kerst[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]$10 parkeerkosten[/ultimate_icon_list_item][/ultimate_icon_list][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.usbr.gov%2Flc%2Fhooverdam%2Fservice%2Findex.html|title:Bestel%20je%20tickets\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612949537564{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Over The Hoover Dam in Nevada\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Op 48 kilometer vanaf <a href=\"https://www.heyusa.com/nl/steden/las-vegas/\" target=\"_blank\" rel=\"noopener\">Las Vegas</a> ligt de Hoover Dam, vernoemd naar oud president Herbert Hoover die een belangrijke rol speelde bij de bouw van de dam. Rond 1920 waren er vele overstromingen in de regio door de smeltende sneeuw uit de Rocky Mountains. De dam zou niet alleen de watertoevoer regelen, ook wekte het elektriciteit op voor de nabije omgeving. Door de aanleg van de dam ontstond een stuwmeer, <a href=\"https://www.heyusa.com/nl/lake-mead/\" target=\"_blank\" rel=\"noopener\">Lake Mead</a>, tegenwoordig een populair recreatiegebied.</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Binnenin de Hoover Dam\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Met een tour krijg je een kijkje in de Hoover Dam\" font_container=\"tag:div|font_size:45|text_align:center\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"4467\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tours bij de Hoover Dam\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Bureau of Reclamation dat het beheer doet van de Hoover Dam, organiseert verschillende rondleidingen bij de Hoover Dam. Zo kun je mee met een rondleiding van 30 minuten waarbij je meer te weten komt over de generatoren waar energie mee wordt opgewekt. Of je gaat mee met een langere rondleiding van 60 minuten waarbij je zelfs een kijkje krijgt in de dam zelf. Wil je niet mee met een tour, maar toch meer weten over de Hoover Dam? Bezoek dan het bezoekerscentrum. Je kunt natuurlijk ook gewoon de auto parkeren en zelf een kijkje nemen op de Hoover Dam![/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.usbr.gov%2Flc%2Fhooverdam%2Fservice%2Findex.html\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"1/2\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"De Hoover Dam ligt op de grens tussen Arizona en Nevada - zoek de grens tussen beide staten op en je hebt in enkele minuten een 1 uur tijdsverschil!\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>Hoover Dam</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Hoover Dam: 05.00 - 21.00 uur (Pacific Time Zone)\r\nVisitor Center: 09.00 - 17.00 uur</strong>[/ultimate_icon_list_item][/ultimate_icon_list][vc_custom_heading text=\"Hoover Dam Museum\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_column_text]In Boulder City vind je het Hoover Dam Museum. Hier maak je kennis met de geschiedenis van de dam en de gevaren van de bouw. Door middel van verhalen van bouwvakkers krijg je een goede indruk van de omstandigheden tijdens de bouw. Het allerleukste is, is dat het museum 365 dagen per jaar geopend is en gratis is te bezoeken.[/vc_column_text][vc_custom_heading text=\"1305 Arizona St, Boulder City\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][ult_buttons btn_title=\"Website Hoover Dam Museum\" btn_link=\"url:https%3A%2F%2Fwww.bchdmuseum.org%2F\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"5/6\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Bezoek ook het nabij gelegen Lake Mead waar je kunt zwemmen, kajakken, varen en kamperen!\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"221 meter hoge Hoover Dam\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:75px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_custom_heading text=\"Wat een plaatje!\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:3\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"4469\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Las Vegas\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:3660,2396,2391,4317\"][/vc_column][/vc_row]","post_title":"De Hoover Dam in Nevada","post_link":"https://www.heyusa.com/nl/hoover-dam-nevada/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hoover Dam Nevada\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/03/Hoover-Dam1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Las Vegas","post_tags":"Nevada","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1612949537564{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}","%_edit_last%":"1","%_edit_lock%":"1724761412:1","%_wpb_vc_js_status%":"true","%post-primary-category%":"54","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"4468","%_yoast_wpseo_focuskw%":"De Hoover Dam in Nevada","%_yoast_wpseo_title%":"De Hoover Dam in Nevada %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Vlak bij Las Vegas vind je de beroemde Hoover Dam Nevada.Een bezienswaardigheid die je niet mag missen. Tips voor je bezoek aan de Hoover Dam.","%_yoast_wpseo_linkdex%":"77","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"Nevada 89005, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Nevada","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"36.0160655","%_wpgmp_metabox_longitude%":"-114.7377325","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_indexnow_last_ping%":"1724669812","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"","taxonomy=category":"Bezienswaardigheden Las Vegas","taxonomy=post_tag":"Nevada","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":4460,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Madame Tussauds in Las Vegas","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Madame Tussauds Las Vegas\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/02/madame-tussauds-las-vegas-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Madame Tussauds in Las Vegas</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"3377 S Las Vegas Blvd Ste. 2001, Las Vegas, NV 89109, Verenigde Staten","location":{"lat":"36.12123","city":"Las Vegas","state":"Nevada","country":"Verenigde Staten","lng":"-115.1714421","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/madame-tussauds-las-vegas/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Madame Tussauds in Las Vegas bezoeken\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">De plek om beroemdheden te spotten is natuurlijk bij Madame Tussauds in Las Vegas. Natuurlijk moet je dit met een korreltje zout nemen, want ondanks dat je ze van dichtbij kunt spotten, zijn deze beroemdheden gemaakt van was. Toch krijg je in Madame Tussauds een realistische weergave van de beroemdheden te zien. Ontdek hoeveel beroemdheden jij herkent in Madame Tussauds Las Vegas en <a href=\"https://www.getyourguide.nl/las-vegas-l58/wassenbeeldenmuseum-madame-tussauds-las-vegas-t9183/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=madametussaudslasvegasintro\" target=\"_blank\" rel=\"noopener\">bestel online alvast je tickets</a>.</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf $40[/ultimate_icon_list_item][/ultimate_icon_list][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Flas-vegas-l58%2Fwassenbeeldenmuseum-madame-tussauds-las-vegas-t9183%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26cmp%3Dmadametussaudslasvegasbuttonboven|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612949537564{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Madame Tussauds\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Op twee verschillende verdiepingen maak je kennis met beroemdheden als Beyonce, Rihanna, Tupac, Angelina Jolie, Brad Pitt en Jamie Fox. Je mag ze aanraken, met ze poseren en niet te vergeten vele selfies maken. En natuurlijk kun je even kijken of je net zo groot bent als Britney Spears. Het werd ooit bedacht door Maria Tussaud, een Fran\u00e7aise die in 1778 haar eerste beeld maakte. Jaren later werden haar wassen beelden tentoongesteld in Engeland. Haar twee zoons besloten na haar overlijden haar tentoonstelling in 1884 te verhuizen naar Madame Tussauds in Londen, de locatie van het huidige museum. Sinds de opening in London zijn er meer dan 25 vestigingen van Madame Tussauds geopend wereldwijd.</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Deze ruimtes mag je niet missen in Madame Tussauds in Las Vegas\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"16933\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Marvel\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Marvel liefhebbers zijn aan het juiste adres in Madame Tussauds. In Madame Tussauds vind je een eerbetoon aan Marvel. Ontmoet superhelden zoals Thor, Captain America, de Hulk of Spiderman en ga met ze op de foto. Tegen betaling kun je een korte film bekijken met 4D special effects. Een unieke ervaring, het lijkt net alsof je meedoet aan de film in plaats van alleen aan het kijken bent.\u00a0</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"16932\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Pop- en filmsterren\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Regelmatig zijn er nieuwe beroemdheden die kunt spotten. Daarnaast is Madame Tussauds interactief. Stap op de Wrecking Ball van Miley Cyrus, maak een muziekvideo met Drake of wordt high met Snoop Dogg.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"16935\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Sport in Madame Tussauds\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Niet alleen beroemdheden uit de film en televisie wereld zijn te vinden in Madame Tussauds in Las Vegas, ook sporthelden kunnen natuurlijk niet ontbreken. Denk aan basketbal legende Michael Jordon of bokser Muhammad Ali.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Spot verschillende popsterren\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ga op de foto met Beyonce\" font_size=\"50\" line_height=\"50\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"16937\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tickets voor Madame Tussauds\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Voor je bezoek aan Madame Tussauds kun je <a href=\"https://www.getyourguide.nl/las-vegas-l58/wassenbeeldenmuseum-madame-tussauds-las-vegas-t9183/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=madametussaudslasvegastekstticket\" target=\"_blank\" rel=\"noopener\">online een ticket aanschaffen</a>. Zo heb je gegarandeerd toegang tot het museum. Voor de Marvel 4D experience dien je een apart ticket aan te schaffen.\r\n\r\nMadame Tussauds is gevestigd in het <a href=\"https://www.heyusa.com/nl/iconische-hotels-las-vegas/\" target=\"_blank\" rel=\"noopener\">Venetian Hotel</a> en Casino, er geldt geen leeftijdsrestrictie.[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Flas-vegas-l58%2Fwassenbeeldenmuseum-madame-tussauds-las-vegas-t9183%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26cmp%3Dmadametussaudslasvegasbuttonbeneden|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"1/2\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>3777 S. Las Vegas Boulevard</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Maandag, dinsdag, woensdag en zondag: 10.00 tot 20.00 uur\r\nDonderdag: 10.00 tot 16.00 uur\r\nVrijdag en zaterdag: 10.00 tot 21.00 uur</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1620887540936{background-color: #dadada !important;}\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][ultimate_heading main_heading=\"Veelgestelde vragen over Madame Tussauds\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:800;\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][vc_toggle title=\"Wat kost een ticket voor Madame Tussauds\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]Je hebt tickets vanaf 40 euro.[/vc_toggle][vc_toggle title=\"Wat is de beste tijd om Madame Tussauds te bezoeken?\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]De beste tijd om Madame Tussauds te bezoeken is in de vroege morgen. Op dat tijdstip is het rustiger dan midden op de dag.[/vc_toggle][vc_toggle title=\"Hoe lang duurt een bezoek aan Madame Tussauds?\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]Je bent ongeveer 1,5 uur kwijt voor een bezoek aan Madame Tussauds[/vc_toggle][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"80%\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Miley Cyrus\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_custom_heading text=\"Wrecking Ball\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:3\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"4344\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Las Vegas\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:4317,3881,3660,2398,2396,2394,298,3720,2400\"][/vc_column][/vc_row]","post_title":"Madame Tussauds in Las Vegas","post_link":"https://www.heyusa.com/nl/madame-tussauds-las-vegas/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Madame Tussauds Las Vegas\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/02/madame-tussauds-las-vegas-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Las Vegas","post_tags":"","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1612949537564{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1620887540936{background-color: #dadada !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"2","%_edit_lock%":"1690806999:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"54","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"16938","%_yoast_wpseo_focuskw%":"Madame Tussauds in Las Vegas","%_yoast_wpseo_title%":"Madame Tussauds in Las Vegas%%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een leuke attractie in Las Vegas is Madame Tussauds. Het wassenbeelden museum is de plek om beroemdheden te spotten en selfies te maken. Koop hier je tickets.","%_yoast_wpseo_linkdex%":"81","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Tickets Madame Tussauds\"]","%_wpgmp_location_address%":"3377 S Las Vegas Blvd Ste. 2001, Las Vegas, NV 89109, Verenigde Staten","%_wpgmp_location_city%":"Las Vegas","%_wpgmp_location_state%":"Nevada","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"36.12123","%_wpgmp_metabox_longitude%":"-115.1714421","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_primary_category%":"54","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1690807073","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","%post_via%":[{"title":"Foto's \u00a9 Madame Tussauds (Madame Tussauds USA) /  Merlin Entertainments Ltd","post_source_url":"https://www.madametussauds.com/"}],"taxonomy=category":"Bezienswaardigheden Las Vegas","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":4337,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Een van de iconen in New York: Brooklyn Bridge","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Brooklyn Bridge\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/02/Brooklyn-Bridge-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Een van de iconen in New York: Brooklyn Bridge</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Brooklyn Bridge, New York, NY 10038, Verenigde Staten","location":{"lat":"40.7060855","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.9968643","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/brooklyn-bridge-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"De mooiste brug van Amerika? De Brooklyn Bridge in New York\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Tussen <a href=\"https://www.heyusa.com/nl/newyork/brooklyn/\">Brooklyn</a> en <a href=\"https://www.heyusa.com/nl/steden/newyork/wijken/\">Manhattan</a> vind je de iconische Brooklyn Bridge. Op het moment van openen was het 's werelds langste hangbrug. Sinds 1883 kunnen voetgangers, fietsers en auto's het water van de East River over via de Brooklyn Bridge. Met een totale lengte van 1825 meter is het een leuke wandeling om van Manhattan naar Brooklyn te maken en vice versa. Wanneer je DUMBO inwandelt, wandel vooral ook even naar het Brooklyn Bridge Park voor fotogenieke plekken op de brug.\u00a0</span>[/vc_column_text][thb_iconbox type=\"left type1\" animation=\"\" icon_image=\"19694\" icon_image_width=\"125\" heading=\"New York expert tip van Marjolein:\" description=\"Je kunt de Brooklyn Bridge natuurlijk van twee kanten oplopen, heb je minder tijd? Kies er dan voor om vanuit Brooklyn te starten. Zo heb je onderweg altijd zicht op de skyline van Manhattan\" thb_heading_color=\"#b34a4c\" thb_text_color=\"#282828\" heading_font_size=\"17px\" description_font_size=\"16px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1613031556007{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"De bouw van de Brooklyn Bridge in New York\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">De architecten van de Brooklyn Bridge in New York zijn John Roebling en zijn zoon Washington Roebling. Uiteindelijk nam de vrouw van Washington, Emily Warren Roebling, de afronding van de Brooklyn Bridge op zich. Washington was niet meer in staat om te werken doordat hij de caissonziekte kreeg tijdens de bouw. Tijdens de bouw kregen meer arbeiders last van deze ziekte. In totaal stierven 27 arbeiders tijdens de bouw van de\u00a0Brooklyn Bridge, niet alleen door de caissonziekte, ook door het vallen van kabels.</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Wandel, fiets of ren over de Brooklyn Bridge\" font_size=\"55\" line_height=\"60\" font_color=\"#ffffff\"][vc_custom_heading text=\"Beleef een van de iconen van New York\" font_container=\"tag:h3|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"20096\"][vc_empty_space height=\"350px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Een aantal leuke facts over de Brooklyn Bridge\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<ul>\r\n \t<li>Opening op 24 mei 1883</li>\r\n \t<li>De lengte van de brug is 1825 meter</li>\r\n \t<li>De grootste overspanning is 486 meter</li>\r\n \t<li>Er zit een stadszegel van Nederlandse afkomst op de brug met de tekst 'Eendragt Maakt Magt'</li>\r\n \t<li>De breedte van de Brooklyn Bridge is 28 meter</li>\r\n \t<li>Pas in 1915 kreeg het zijn huidige naam, in eerste instantie werd de brug de 'New York en Brooklyn Bridge' en 'East River Bridge' genoemd</li>\r\n \t<li>Tegenwoordig gaan er gemiddeld 120.000 auto's, 4000 voetgangers en 2600 fietsers over de Brooklyn Bridge</li>\r\n \t<li>Wanneer je de brug over wandelt vanaf Manhattan kom je in de wijk <a href=\"https://www.heyusa.com/nl/new-york/dumbo/\" target=\"_blank\" rel=\"noopener\">DUMBO</a> in Brooklyn uit.</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"De opening in 1883\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Op 24 mei 1883 werd de Brooklyn Bridge voor het eerst in gebruik genomen. Emily Warren Roebling was de eerste die de stap waagde. Daarna volgden ruim 1800 voertuigen en 150.000 voetgangers haar voorbeeld die dag. In hetzelfde jaar kwam een vrouw met haar hak klem te zetten tussen de planken. Doordat ze begon te schreeuwen, raakten mensen in paniek. Mensen dachten dat de brug in zou storten, wat uiteindelijk resulteerde in dat 12 mensen doodgedrukt werden die dag. Om mensen gerust te stellen liet circushouder P.T. Barnum 21 olifanten pareren over de Brooklyn Bridge.\r\n</span>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Foto's van de Brooklyn Bridge\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][thb_image_slider images=\"6978,10235,10236,10237,10239\"][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1704447364483{background-color: #f2f2f2 !important;}\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"MEER PLEKJES?\r\nCHECK DE GRATIS HEY!USA APP!\" font_container=\"tag:h2|font_size:50|text_align:center|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_row_inner][vc_column_inner width=\"1/4\"][/vc_column_inner][vc_column_inner width=\"1/2\"][thb_image retina=\"retina_size\" alignment=\"aligncenter\" image=\"11640\" img_size=\"medium\" img_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fheyusa-app%2F|title:Hey!USA%20app|target:_blank\"][/thb_image][vc_custom_heading text=\"Honderden unieke, bijzondere, verborgen plekjes in New York City? Plus de klassiekers \u00e9n zien waar je bent in de stad? Download dan de gratis Hey!USA-app!\" font_container=\"tag:p|font_size:20|text_align:center|color:%23282828|line_height:1.5\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\" link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fheyusa-app%2F|title:Hey!USA%20app\"][ult_buttons btn_title=\"HEY!USA APP\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fheyusa-app%2F|title:Hey!USA%20app|target:_blank\" btn_align=\"ubtn-center\" btn_size=\"ubtn-small\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:25px;\" btn_line_height=\"desktop:30px;\"][vc_empty_space height=\"25px\"][/vc_column_inner][vc_column_inner width=\"1/4\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York:\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:1759,1875,1784,1571\"][/vc_column][/vc_row]","post_title":"Een van de iconen in New York: Brooklyn Bridge","post_link":"https://www.heyusa.com/nl/brooklyn-bridge-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Brooklyn Bridge\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/02/Brooklyn-Bridge-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden New York","post_tags":"","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1613031556007{background-color: #ededed !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1704447364483{background-color: #f2f2f2 !important;}","%_edit_last%":"2","%_edit_lock%":"1718177002:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"14","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"4027","%_yoast_wpseo_focuskw%":"Brooklyn Bridge in New York","%_yoast_wpseo_metadesc%":"Een van 's werelds meest bekende bruggen vind je in New York: Brooklyn Bridge. Kom alles te weten over deze prachtige brug in New York.","%_yoast_wpseo_linkdex%":"73","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"Brooklyn Bridge, New York, NY 10038, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7060855","%_wpgmp_metabox_longitude%":"-73.9968643","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1718098903","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","%_yoast_wpseo_primary_category%":"","taxonomy=category":"Bezienswaardigheden New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":4009,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Mob Museum Las Vegas","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Mob Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/01/Mob-Museum2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Mob Museum Las Vegas</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"300 Stewart Ave, Las Vegas, NV 89101, Verenigde Staten","location":{"lat":"36.17281979999999","city":"Las Vegas","state":"Nevada","country":"Verenigde Staten","lng":"-115.1412395","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/mob-museum-las-vegas/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text]<strong>The Mob Museum in Las Vegas is een historisch museum gevestigd in Downtown Las Vegas, twee blokken van Freemont Street. Op 14 februari 2012 werd het museum geopend waar je alles te weten komt over de geschiedenis van de georganiseerde misdaad in Amerika. Door middel van tentoonstellingen en verhalen kom je alles te weten over The Mob in Amerika.</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"300 Stewart Ave\"][vc_empty_space height=\"25px\"][thb_button size=\"large\" link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fthe-mob-museum-l5855%2Flas-vegas-the-mob-museum-t38523%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dmobmuseumlv|title:BOEK%20JE%20TICKETS|target:_blank\" icon=\"fas fa-cart-plus\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"The Mob in Las Vegas\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In een prachtig gerestaureerd voormalig US Post Office en gerechtsgebouw vind je het Mob Museum. Ga mee op een interactieve tour door het museum en maak kennis met de georganiseerde misdaad en wetshandhaving van de start van de Mob tot de hedendaagse maffia.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"The American Mob\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\" margin_design_tab_text=\"\"][/ultimate_heading][ultimate_heading main_heading=\"Duik in de interessante geschiedenis van de maffia\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"3741\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"In het Mob Museum in Las Vegas\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Birth of the Mob\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">De geschiedenis van de maffia in Amerika brengt je terug naar de ghetto's in diverse steden aan het einde van de 19e eeuw, veelal bewoond door Ierse, Italiaanse en Oost- Europese Joodse immigranten. Zij hadden grote moeite om te overleven, er bestond veel armoede, discriminatie en overbevolking. In plaats van te kiezen voor de laagbetaalde banen, kozen sommige nieuwkomers voor de kortste klap om rijk te worden. Zij vormden straatbendes en misdaadsyndicaten en namen de straten over in sommige steden.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Historic Courtroom\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Het Mob Museum bevindt zich in het eerste gerechtsgebouw en postkantoor van Amerika. Het werd geopend in 1933 en hier werd de beroemdste hoorzitting ooit gehouden. In de rechtszaal op de tweede verdieping werd op 15 november 1950 een zaak gepresenteerd over de betrokkenheid van de georganiseerde misdaad in de casino industrie in Las Vegas. De zaal is gerestaureerd en ziet eruit zoals tijdens de rechtszaak in 1950.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"St. Valentine's Day Massacre\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Chicago vormde decor voor een van de meest gruwelijke schietpartijen in de geschiedenis van de maffia. Op 14 februari 1929, St. Valentine's Day, werden zeven leden en medewerkers van de bende van George Moran opgesteld tegen een muur en doodgeschoten in de garage aan North Clark Street 2122. Al Capone werd verdacht van deze schietpartij, maar niemand werd ooit vervolgd. Driehonderd stenen van de garage zijn te zien in het Mob Museum.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Het iconische Mob Museum\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Het eerste gerechtsgebouw en postkantoor van Amerika\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"10508\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Las Vegas:\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:4348,4434,5897,4460\"][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"Mob Museum Las Vegas","post_link":"https://www.heyusa.com/nl/mob-museum-las-vegas/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Mob Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/01/Mob-Museum2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Las Vegas","post_tags":"","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1642684891:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"54","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Mob Museum Las Vegas","%_yoast_wpseo_metadesc%":"Amerika en de maffia hebben een verleden waar je niet om heen kan. In het Mob Museum in Las Vegas kom je alles te weten over de maffia.","%_yoast_wpseo_linkdex%":"76","%_wpgmp_location_address%":"300 Stewart Ave, Las Vegas, NV 89101, Verenigde Staten","%_wpgmp_location_city%":"Las Vegas","%_wpgmp_location_state%":"Nevada","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"36.17281979999999","%_wpgmp_metabox_longitude%":"-115.1412395","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"54","%_thumbnail_id%":"3742","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1677015422","taxonomy=category":"Bezienswaardigheden Las Vegas","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":3660,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Broadway in New York","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Broadway\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/01/Broadway2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Broadway in New York</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Broadway, New York, NY, Verenigde Staten","location":{"lat":"40.81241989999999","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.96053429999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/broadway-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"25px\"][vc_custom_heading text=\"Broadway Musicals in New York\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Broadway in New York staat synoniem voor de theater - en musicalwereld van de stad. Het is de plek om een musical te bekijken in New York. In New York vind je op Broadway musicals als The Lion King, Phantom of the Opera of Wicked. Enorm populaire musicals die het al jaren goed doen op Broadway. Het is de plek waar je naar toe moet om een musical te bekijken!\r\n</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar voorstellingen[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-map-marker\"]Rond 42nd Street[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-subway\"]Times Square - 42 Street - 1 | 2 | 3 | 7[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1640071725094{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Broadway theater\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">Broadway refereert in eerste instantie naar de 41 professionele theaters in <a href=\"https://www.heyusa.com/nl/new-york/midtown-manhattan/\" target=\"_blank\" rel=\"noopener\">Midtown Manhattan</a>. Deze theaters hebben 500 stoelen of meer. Je vindt hier, samen met West End in Londen, de hoogste concentratie aan commerci\u00eble theaters. Broadway is een populaire toeristische attractie in New York. Meer dan 14 miljoen mensen bezoeken jaarlijks een voorstelling op Broadway.</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1640071948496{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Musical posters op Times Square\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Naar welke musical ga jij?\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"3435\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1640072038142{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Tickets scoren voor een Broadway Musical\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Tickets kun je voor je reis al online aanschaffen, maar vaak zijn deze redelijk prijzig. Wil je goedkopere tickets scoren? Dan kun je bij de TKTS Booth op Duffy Square en in <a href=\"https://www.heyusa.com/nl/newyork/newyorkcity/buurten/lower-manhattan/\" target=\"_blank\" rel=\"noopener\">Lower Manhattan</a> in de rij staan voor de laatste tickets. Het zijn kaarten voor shows op de dag zelf en vaak zijn ze voor de helft van de prijs te verkrijgen. Voor studenten zijn er vaak goedkopere dagkaarten beschikbaar.[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"3438\" img_size=\"large\"][vc_custom_heading text=\"De Lion King op Broadway\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In het Minskoff Theatre kun je al een aantal jaren genieten van de voorstelling van de Lion King. Prachtige decors en kostuum, levensgrote dieren en herkenbare songs komen voorbij in een van de mooiste musicals ooit. De musical duurt bijna 3 uur en is echt de moeite waard om bij te wonen in New York.[/vc_column_text][ult_buttons btn_title=\"Boek hier je tickets voor The Lion King\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fnyc-the-lion-king-broadway-tickets-t20493%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dbroadwaylionking|title:Tickets%20Chicago|target:_blank\" btn_size=\"ubtn-small\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"3439\" img_size=\"large\"][vc_custom_heading text=\"Chicago op Broadway\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In het Ambassador Theater op Broadway wordt de musical Chicago opgevoerd. Het verhaal speelt zich af in Chicago tijdens de drooglegging tussen 1920-1933. De musical is bekroond met vele awards, waaronder zes Tony Awards en een Grammy. Het is ook een van de meest populaire shows op Broadway.[/vc_column_text][ult_buttons btn_title=\"Boek hier je tickets voor Chicago\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fbroadway-new-york-l3362%2Fnew-york-city-chicago-the-musical-broadway-tickets-t294890%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26utm_source%3Dnwyrk_media%26placement%3D%2522other%2522%26cmp%3Dbroadwaynewyork|title:Tickets%20Chicago|target:_blank\" btn_size=\"ubtn-small\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"3440\" img_size=\"large\"][vc_custom_heading text=\"Phantom of the Opera op Broadway\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Sinds 1988 kun je Phantom of the Opera bewonderen in het Majestic Theater op Broadway. Phantom of the Opera wordt al zoveel jaren opgevoerd, dat het inmiddels de langst spelende musical is op Broadway. Het blijft prachtig om de indrukwekkende decors, kostuums en muziek voorbij zien te komen. En daarnaast is ook Phantom of the Opera een echte klassieker die je niet mag missen.[/vc_column_text][ult_buttons btn_title=\"Boek hier je tickets voor Phantom of the Opera\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fnyc-the-phantom-of-the-opera-broadway-tickets-t295230%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dbroadwayphantom|title:Tickets%20Chicago|target:_blank\" btn_size=\"ubtn-small\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"12599\" img_size=\"large\"][vc_custom_heading text=\"Aladdin op Broadway\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In het historische New Amsterdam Theatre kun je kijken hoe Disney's Aladdin The Musical tot leven komt. Luister naar alle bekende nummers van award winnende muziek en nieuwe nummers die speciaal voor de musical geschreven zijn. Aladdin is een onvergetelijke musical met prachtige decors, kostuums en verlichting.[/vc_column_text][ult_buttons btn_title=\"Boek hier je tickets voor Aladdin\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fnyc-aladdin-broadway-tickets-t42619%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dbroadwayaladdin|title:Tickets%20Aladdin|target:_blank\" btn_size=\"ubtn-small\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"12601\" img_size=\"large\"][vc_custom_heading text=\"Moulin Rouge op Broadway\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Moulin Rouge is een jukeboxmusical gebaseerd op de film <a href=\"https://www.imdb.com/title/tt0203009/?ref_=nv_sr_srsg_0\" target=\"_blank\" rel=\"noopener\">Moulin Rouge</a>. Vanaf 2019 is Moulin Rouge te aanschouwen in het Al Hirschfeld Theatre op Broadway. Moulin Rouge is inmiddels veelgeprezen musical, bij de 74 Tony Awards ontvingen ze 14 nominaties en wonnen ze 10 prijzen, waaronder die voor beste musical. Tijd om het verhaal van Moulin Rouge op de b\u00fchne te zien.[/vc_column_text][ult_buttons btn_title=\"Boek hier je tickets voor Moulin Rouge\" btn_link=\"url:https%3A%2F%2Fmoulinrougemusical.com%2Fnew-york%2Fhome%2F|title:Tickets%20Moulin%20Rouge|target:_blank\" btn_size=\"ubtn-small\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"12600\" img_size=\"large\"][vc_custom_heading text=\"Harry Potter op Broadway\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Harry Potter en het Vervloekte Kind is een nieuw toneelstuk van Jack Throne. Het is het achtste verhaal in de Harry Potter serie en het eerste offici\u00eble Harry Potter verhaal dat op het podium wordt gepresenteerd. Harry Potter is inmiddels werknemer van het Ministerie van Toverkunst, echtgenoot en vader van drie kinderen. Ontdek de nieuwe wereld van Harry Potter op Broadway.[/vc_column_text][ult_buttons btn_title=\"Boek hier je tickets voor Harry Potter\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fbroadway-new-york-l3362%2Fnyc-harry-potter-and-the-cursed-child-broadway-tickets-t284037%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dbroadwayharrypotter|title:Tickets%20Harry%20Potter|target:_blank\" btn_size=\"ubtn-small\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1619098125380{padding-top: 75px !important;padding-bottom: 75px !important;background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2021/02/background-dc-light.gif?id=4055) !important;}\"][vc_column][fullwidth_row content_width=\"75%\"][ultimate_heading main_heading=\"Do's &amp; Don'ts voor een musical bezoek in New York\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Voordat je een musical in New York gaat bezoeken is het handig om een paar do\u2019s en dont\u2019s te weten.</p>\r\n[/vc_column_text][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Do's\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_column_text]\r\n<ul>\r\n \t<li>Ben je tijdens Broadway week in New York? Dan heb vaak de kans op 2 voor de prijs van 1</li>\r\n \t<li>Print je tickets voor die tijd, bij sommige theaters kun je alleen met geprinte tickets binnenkomen</li>\r\n \t<li>Ga voor die tijd langs je hotel om al je tassen te droppen</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Don'ts\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_column_text]\r\n<ul>\r\n \t<li>Alleen focussen op de grote musical op Broadway, soms zijn de off-Broadway shows net zo leuk</li>\r\n \t<li>Eten &amp; drinken in het theater kopen, de prijzen zijn enorm</li>\r\n \t<li>Op het laatste moment je tickets ophalen bij de ticket box, de rijen zijn vaak enorm</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Enjoy the show!\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][vc_custom_heading text=\"Met meer dan 41 theaters op Broadway, veel keuze!\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"3437\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York:\" font_container=\"tag:div|font_size:55|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"25px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:3408,506,1559,1484\"][/vc_column][/vc_row]","post_title":"Broadway in New York","post_link":"https://www.heyusa.com/nl/broadway-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Broadway\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/01/Broadway2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden New York","post_tags":"","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1640071725094{background-color: #ededed !important;}.vc_custom_1640071948496{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1640072038142{background-color: #ededed !important;}.vc_custom_1619098125380{padding-top: 75px !important;padding-bottom: 75px !important;background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2021/02/background-dc-light.gif?id=4055) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1706262773:1","%_wpb_vc_js_status%":"true","%post-primary-category%":"14","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"3436","%_yoast_wpseo_focuskw%":"Broadway in New York","%_yoast_wpseo_metadesc%":"Bezoek een musical op Broadway in New York. De plek in New York om musicals te bekijken. Bezoek onder andere de Lion King op Broadway.","%_yoast_wpseo_linkdex%":"73","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"New York Musical\"]","%_wpgmp_location_address%":"Broadway, New York, NY, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.81241989999999","%_wpgmp_metabox_longitude%":"-73.96053429999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_title%":"Musical op %%title%% %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1705578061","%_last_editor_used_jetpack%":"classic-editor","%activeer_submenu%":"1","%_activeer_submenu%":"field_6593f521e97c2","%locatie_submenu%":"Selecteer een pagina","%_locatie_submenu%":"field_6593f531e97c3","%selecteer_pagina%":"18453","%_selecteer_pagina%":"field_6593f8be019da","%_yoast_wpseo_primary_category%":"","taxonomy=category":"Bezienswaardigheden New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":3431,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Wedstrijd van de Yankees bijwonen","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Yankees Stadium\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/01/Yankees-stadium-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Wedstrijd van de Yankees bijwonen</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1 E 161 St, The Bronx, NY 10451, Verenigde Staten","location":{"lat":"40.8296426","state":"New York","country":"Verenigde Staten","lng":"-73.9261745","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/new-york-yankees-wedstrijd/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Wedstrijd van de Yankees bijwonen\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Als sportliefhebber is het een super toffe ervaring om een sportwedstrijd bij te wonen in New York. Bij The Yankees in The Bronx maak je een ultieme sportervaring mee. </span>De New York Yankees zijn het bekendste honkbalteam van New York en waarschijnlijk zelfs van heel Amerika. Het team, dat speelt in het bekende Yankee Stadium in de Bronx, is al vele jaren een van de topploegen in de honkbalcompetitie MLB. Een bezoek aan een wedstrijd van de \u2018Bronx Bombers\u2019, zoals hun bijnaam luidt, mag eigenlijk niet ontbreken in je citytrip New York! Let\u2019s go Yankees\u2026.\r\n<div class=\"edgtf-separator-holder clearfix edgtf-separator-center \">\r\n<div class=\"edgtf-separator\"></div>\r\n</div>\r\n[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]Seizoen loopt van april tot oktober[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Tussen de $10 en $105[/ultimate_icon_list_item][/ultimate_icon_list][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.mlb.com%2Fyankees%2Ftickets|title:Bestel%20je%20tickets\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#000000\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612789513968{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Over The Yankees\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">De New York Yankees zijn sinds 1920 een van de beroemdste en meest succesvolle clubs in de Amerikaanse beroepssport. De Yankees werden opgericht in 1901 in Baltimore, Maryland. Daar speelden ze onder de naam Baltimore Orioles (het huidige team uit Baltimore gebruikt nu die naam). Begin 1903 kochten Frank Farrell en Bill Devery de club voor de American League en verhuisden het team naar Manhattan. Vanaf 1923 speelden de Yankees in het Yankee Stadium waar ze tot 2008 speelden alvorens ze naar het nieuwe Yankee Stadium in The Bronx verhuisden. </span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Yankee Stadium\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:1px;\"][/ultimate_heading][vc_custom_heading text=\"De thuisbasis van The Yankees\" font_container=\"tag:div|font_size:35|text_align:center|color:%23ffffff|line_height:3\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"3420\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Yankee Stadium\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Sinds 1923 spelen de Yankees in het Yankee Stadium in The Bronx. Inmiddels spelen ze niet meer in het originele stadion van 1923, want in 2009 is het nieuwe stadion pal naast het oude gebouwd, maar heeft het dezelfde naam gehouden. Op de plek van het oorspronkelijke stadion ligt nu een park. In het stadion passen zo\u2019n 47.309 mensen. Sinds 2015 heeft de MLS voetbalclub New York City FC een aantal jaren de thuiswedstrijden gespeeld in het Yankee Stadium tot hun eigen stadion klaar is voor gebruik. In het stadion is ook het New York Yankees Museum te vinden vlakbij gate 6. Hierin vind je alle memorabilia rondom The Yankees. Daarnaast is Monument Park een aanrader om te bezoeken wanneer je in het stadion bent. Hier vind je de \u2018retired\u2019 nummers van oude honkballers van de Yankees.[/vc_column_text][vc_custom_heading text=\"Tickets voor The Yankees\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Tickets voor de Yankees heb je al vanaf $10, maar kunnen gerust ook enkele duizenden dollars kosten. Een redelijke prijs is tussen de $35 en $65 voor een kaartje. Het mooiste zicht heb je achter de thuisplaat. Hoe lager het vak nummer, hoe dichter bij de thuisplaat. De 400 serie bevindt zich bijvoorbeeld helemaal bovenin het stadion, terwijl je in de 100 serie dicht op het veld zit. Wil je alleen sfeerproeven, dan is het prima om bovenin te zitten.[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.mlb.com%2Fyankees%2Ftickets\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#000000\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"1/2\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Ook al heb je niet zoveel met honkbal, een bezoek aan The Yankees is een echter Amerikaanse ervaring en ook dan de moeite waard\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>1 E 161 Street</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>April t/m oktober</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-subway\"]<strong>161st - 4</strong>[/ultimate_icon_list_item][/ultimate_icon_list][vc_custom_heading text=\"Hoe kom je bij het Yankee Stadium?\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_column_text]Het Yankee Stadium is te bereiken met de metro vanaf Manhattan. 161st Street is de halte vlakbij het stadion waar lijn 4 stopt.\r\n\r\nOm niets te missen van de wedstrijd is het handig om een uur tot een half uur voor de wedstrijd aanwezig te zijn. Mocht je iets eerder zijn, dan vermaak je je nog prima in het stadion en kun je bij Monument Park een kijkje nemen. Hier kun je tot 45 minuten van te voren terecht om het memorial voor voormalige Yankee honkballers te bekijken.[/vc_column_text][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"5/6\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Bezoek ook Monument Park en loop langs de helden van The Yankees\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Monument Park\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_custom_heading text=\"De helden van de Yankees\" font_container=\"tag:div|font_size:25|text_align:center|color:%23ffffff|line_height:3\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"3415\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York\" font_container=\"tag:div|font_size:50|text_align:center|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"by_id:1759,3396,1571,1697\"][/vc_column][/vc_row]","post_title":"Wedstrijd van de Yankees bijwonen","post_link":"https://www.heyusa.com/nl/new-york-yankees-wedstrijd/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Yankees Stadium\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/01/Yankees-stadium-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden New York","post_tags":"","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1612789513968{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}","%_edit_last%":"2","%_edit_lock%":"1679551787:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"14","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_yoast_wpseo_focuskw%":"Wedstrijd van de Yankees bijwonen","%_yoast_wpseo_title%":"Wedstrijd van de Yankees bijwonen in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Sportliefhebber? Dan moet je echt een wedstrijd van de Yankees bijwonen in The Bronx. Tips voor het kopen van tickets voor The Yankees.","%_yoast_wpseo_linkdex%":"64","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"1 E 161 St, The Bronx, NY 10451, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.8296426","%_wpgmp_metabox_longitude%":"-73.9261745","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_thumbnail_id%":"15453","%_yoast_indexnow_last_ping%":"1679551449","%_last_editor_used_jetpack%":"classic-editor","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Bezienswaardigheden New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":3408,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Vrijheidsbeeld &#038; Ellis Island in New York","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Vrijheidsbeeld\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/01/Vrijheidsbeeld2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Vrijheidsbeeld &#038; Ellis Island in New York</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Liberty island, NY 10004, Verenigde Staten","location":{"lat":"40.68929929999999","city":"Liberty island","state":"New York","country":"Verenigde Staten","lng":"-74.0443815","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/vrijheidsbeeld-ellis-island-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Vrijheidsbeeld - icoon van New York\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een van de symbolen van New York die je eigenlijk niet kunt missen tijdens je stedentrip: Het Vrijheidsbeeld in New York. Niet alleen vaar je met de boot langs de skyline van Manhattan, je kunt met de juiste tickets zelfs de kroon van het Vrijheidsbeeld beklimmen. Naast een bezoek aan het Vrijheidsbeeld, kom je met hetzelfde ticket ook langs Ellis Island. Het vroegere immigratiestation is te bezoeken en maakt veel indruk met alle geschiedenis die je er kunt vinden.[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-arrows-v\"]93 meter hoog[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-calendar\"]363 dagen per jaar geopend - met Kerst en Thanksgiving gesloten[/ultimate_icon_list_item][/ultimate_icon_list][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fstatue-of-liberty-ellis-island-ticket-options-with-ferry-t393246%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dvrijheidsbeeldenellisislandboven|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#000000\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612790381563{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Over het Vrijheidsbeeld in New York\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">Het symbool van de vrijheid is een van de meest bekende attracties van New York. Met een hoogte van 93 meter staart hij over de wateren rondom Manhattan. Een cadeau van de Fransen in 1884 als teken van vriendschap. In 1885 arriveerde Lady Liberty in New York. De 350 verschillende stukken werden in elkaar gezet in en op 28 oktober 1886 werd het beeld ingehuldigd. Sinds 1924 is het</span><span style=\"font-weight: 400;\">\u00a0een Nationaal Monument.</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"93 meter hoog\" font_container=\"tag:div|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Lady Liberty\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"15488\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Ellis Island\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Het eiland naast het Vrijheidsbeeld is Ellis Island. Het was de eerste kennismaking voor vele inwoners in Amerika met het land. In de 19e en 20e eeuw deed het dienst als grenspost voor immigranten, de eerste stop in Amerika. Rond 1770 was het eigendom van Samuel Ellis van wie het de naam heeft gekregen. Nadat Castle Clinton te klein werd, begon men op Ellis Island met het ontvangen van immigranten. Van 1 januari 1892 tot 29 november 1954 moesten immigranten via het eiland voor de kust van Manhattan. Meer dan 12 miljoen mensen kwamen in deze jaren Amerika binnen via Ellis Island.</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Vrijheidsbeeld bezoeken - tips\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Om het Vrijheidsbeeld te bezoeken dien je een ticket bij Statue Cruises te kopen. Hiervoor zijn verschillende tickets beschikbaar. Er zijn namelijk een beperkt aantal kaarten beschikbaar voor de kroon van het Vrijheidsbeeld. Met de meest gangbare tickets heb je alleen toegang tot de sokkel. De aller goedkoopste tickets geven hier geen toegang toe. Bestel dus ruim van te voren je tickets voor de kroon om je bezoek onvergetelijk te maken.</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Ellis Island bezoeken\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Bij alle tickets zit een bezoek aan Ellis Island inbegrepen. Je kunt dit niet los van elkaar boeken. Overigens kun je natuurlijk wel direct de boot pakken vanaf het Vrijheidsbeeld mocht je dat willen. Op Ellis Island vind je het <a href=\"https://www.heyusa.com/nl/new-york/ellis-island-museum/\" target=\"_blank\" rel=\"noopener\">Ellis Island Museum</a> vol informatie en verhalen van allerlei immigranten die in Amerika aankwamen. In diverse hallen kom je alles te weten over de gebeurtenissen tussen 1892 en 1954. Je kunt je wel een dag vermaken in Ellis Island, zoveel is er te lezen. Neem dus de tijd voor een bezoek aan het Vrijheidsbeeld en Ellis Island.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Ellis Island\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Kom alles te weten over het migranten verleden van New York\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"3403\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tickets voor het Vrijheidsbeeld en Ellis Island in New York\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Met de ferry vertrek je vanaf Battery Park naar het Vrijheidsbeeld. Je ticket is geldig voor zowel het Vrijheidsbeeld als Ellis Island. Bij het Vrijheidsbeeld zijn er wel verschillende tickets beschikbaar:</span>\r\n<ul>\r\n \t<li>Crown Ticket - tot de kroon van het Vrijheidsbeeld: vanaf $24,80</li>\r\n \t<li>Sokkel Ticket - tot in de sokkel van het Vrijheidsbeeld: vanaf $24,50</li>\r\n \t<li>Reserve Ticket - toegang tot het terrein van het Vrijheidsbeeld: vanaf $19,25</li>\r\n</ul>\r\n[/vc_column_text][vc_custom_heading text=\"Online tickets bestellen Vrijheidsbeeld\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Wil je een Crown Ticket bemachtigen? Dan dien je ruim van te voren te reserveren. Ook de Sokkel Tickets zijn een paar dagen van te voren vaak al uitverkocht. Het loont dus om vanuit huis al deze tickets <a href=\"https://www.getyourguide.com/new-york-city-l59/statue-of-liberty-ellis-island-ticket-options-with-ferry-t393246/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=vrijheidsbeeldenellisislandintekst\" target=\"_blank\" rel=\"noopener\">online</a> te bestellen. Tijdens je verblijf zelf kun je tickets kopen bij Castle Clinton in Battery Park.</span>[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fstatue-of-liberty-ellis-island-ticket-options-with-ferry-t393246%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dvrijheidsbeeldenellisislandonder|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#000000\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"1/2\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Mocht je geen budget hebben om het Vrijheidsbeeld te bezoeken. Pak dan de gratis Staten Island Ferry en zie het Vrijheidsbeeld van dicht bij.\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>Battery Park</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Dagelijks van ongeveer 9.00 - 15.30 uur</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<strong>Met Kerst en Thanksgiving zijn het Vrijheidsbeeld en Ellis Island gesloten</strong>[/ultimate_icon_list_item][/ultimate_icon_list][vc_custom_heading text=\"Korting op tickets voor het Vrijheidsbeeld\" font_container=\"tag:h2|font_size:15|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Er zijn mogelijkheden om het Vrijheidsbeeld te bezoeken met korting. Hiervoor kun je het beste een <a href=\"https://www.heyusa.com/nl/voordeelpassen-new-york/\">voordeelpas van New York</a> aanschaffen. Je hoeft niet een specifieke datum al vast te leggen, maar moet wel een tijdstip reserveren.[/vc_column_text][vc_custom_heading text=\"Wat is het beste moment om het Vrijheidsbeeld te bezoeken?\" font_container=\"tag:h2|font_size:15|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De beste tijd om het Vrijheidsbeeld en Ellis Island te bezoeken is op de vroege morgen. Je bent dan als een van de eersten op de eilanden en hebt alle ruimte voor jezelf.[/vc_column_text][vc_row_inner thb_max_width=\"\"][vc_column_inner box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Het allermooiste is om de kroon van het Vrijheidsbeeld te bezoeken. De tickets zijn hiervoor beperkt, mocht je te laat zijn, probeer in ieder geval om het Vrijheidsbeeld van binnen te bezoeken.\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York\" font_container=\"tag:div|font_size:50|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"by_id:1767,-1747,1559,1484,1619\"][/vc_column][/vc_row]","post_title":"Vrijheidsbeeld &#038; Ellis Island in New York","post_link":"https://www.heyusa.com/nl/vrijheidsbeeld-ellis-island-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Vrijheidsbeeld\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/01/Vrijheidsbeeld2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden New York","post_tags":"","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1612790381563{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}","%_edit_last%":"2","%_edit_lock%":"1718125325:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"14","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":[{"title":"Foto credit: Julienne Schaer/NYC & Company","post_source_url":"http://www.nycgo.com"}],"%_thumbnail_id%":"3405","%_yoast_wpseo_focuskw%":"Vrijheidsbeeld","%_yoast_wpseo_title%":"Vrijheidsbeeld & Ellis Island in New York bezoeken %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Het Vrijheidsbeeld en Ellis Island in New York, een van de leukste bezienswaardigheden om te bezoeken in New York.","%_yoast_wpseo_linkdex%":"84","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Ellis Island\"]","%_wpgmp_location_address%":"Liberty island, NY 10004, Verenigde Staten","%_wpgmp_location_city%":"Liberty island","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.68929929999999","%_wpgmp_metabox_longitude%":"-74.0443815","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_indexnow_last_ping%":"1690446874","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_primary_category%":"","taxonomy=category":"Bezienswaardigheden New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":3396,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Prospect Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Prospect Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/11/Prospect-Park-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Prospect Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Brooklyn, New York, Verenigde Staten","location":{"lat":"40.6602037","state":"New York","country":"Verenigde Staten","lng":"-73.9689558","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/prospect-park-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"25px\"][vc_custom_heading text=\"Prospect Park in New York\" font_container=\"tag:h2|font_size:45|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Centrale hart van Brooklyn\" font_container=\"tag:p|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"100px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Eigen Central Park in Brooklyn\" font_container=\"tag:h2|font_size:25|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Wat Manhattan heeft met Central Park, heeft Brooklyn met Prospect Park. Het openbare park is ontworpen door Frederick Law Olmsted en Calvert Vaux nadat zij Central Park hadden voltooid. Rond 1859 was Brooklyn een van de grootste \u2018steden\u2019 van Amerika en daarin kon een park natuurlijk niet ontbreken. Een twintigtal jaren later was het park compleet en had Brooklyn zijn eigen <a href=\"https://www.heyusa.com/nl/new-york-city/central-park/\" target=\"_blank\" rel=\"noopener noreferrer\">Central Park</a>. Een park met daarin genoeg ruimte voor allerlei sportgelegenheden, een meer en diverse events gedurende het jaar.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Prospect Zoo\" font_container=\"tag:h2|font_size:25|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Net als Central Park heeft ook Prospect Park een eigen dierentuin. Op 4.9 hectare bevinden zich meer dan 400 dieren van ongeveer 100 verschillende soorten. <a href=\"https://prospectparkzoo.com/\" target=\"_blank\" rel=\"noopener noreferrer\">Prospect Zoo</a> werd in 1935 geopend en ging in 1988 tijdelijk dicht voor een grote renovatie. In 1993 werd de dierentuin weer geopend die sindsdien valt het onder het Wildlife Conservation Society.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Picnic House\" font_container=\"tag:h2|font_size:25|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een charmante en historische locatie in Prospect Park is het Picnic House. Aan het Long Meadow gelegen heb je vanaf het Picnic House uitzicht over de grasvelden. Het is mogelijk om bij het <a href=\"https://www.prospectpark.org/visit-the-park/weddings-and-special-events/picnic-house/\" target=\"_blank\" rel=\"noopener noreferrer\">Picnic House</a> te eten, maar je kunt het bijvoorbeeld ook afhuren voor een speciale gelegenheid.[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_column_text]\r\n\r\n[/vc_column_text][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"100%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"960\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"LENTE &amp; ZOMER\" heading_tag=\"p\" main_heading_color=\"#000000\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In de zomerweekenden is Prospect Park een druk bezochte plek. De inwoners van Brooklyn zoeken de zon of juist verkoeling op van het park. In deze maanden organiseren diverse sportclubs hun evenementen. Zo worden er onder andere softbal games gespeeld of zijn er hardloopwedstrijden in het park. Culturele activiteiten kunnen ook niet ontbreken in de zomermaanden.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"5360\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"WINTER &amp; KERST\" heading_tag=\"p\" main_heading_color=\"#000000\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Waar de meeste parken redelijk verlaten zijn in de winter, kun je je in Prospect Park prima vermaken. Er zijn ijsbanen waar geschaatst kan worden, je kunt crosscountry ski\u00ebn en natuurlijk van de heuvels afglijden met de slee. Zo is vlakbij de ingang van 10th een populaire heuvel te vinden om vanaf te glijden.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Het groene hart\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Van Brooklyn\" font_container=\"tag:div|font_size:45|text_align:center\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"9314\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York\" font_container=\"tag:div|font_size:50|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:4009,1233,910,1606\"][/vc_column][/vc_row]","post_title":"Prospect Park","post_link":"https://www.heyusa.com/nl/prospect-park-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Prospect Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/11/Prospect-Park-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Parken New York","post_tags":"","%_edit_last%":"1","%_edit_lock%":"1633530993:1","%_wpb_vc_js_status%":"true","%post-primary-category%":"13","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%_hide_featured%":null,"%_thumbnail_id%":"5362","%_wp_old_date%":"2020-07-14","%inline_featured_image%":"0","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Prospect Park in New York","%_yoast_wpseo_title%":"%%title%% in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Prospect Park in New York is het groene hart van Brooklyn. Benieuw wat je kunt doen in Prospect Park? Tips voor je bezoek aan Prospect Park.","%_yoast_wpseo_linkdex%":"71","%_yoast_wpseo_content_score%":"60","%_wpgmp_location_address%":"Brooklyn, New York, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.6602037","%_wpgmp_metabox_longitude%":"-73.9689558","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_wpb_shortcodes_custom_css%":".vc_custom_1582906882917{padding-top: 25px !important;}","%_yoast_indexnow_last_ping%":"1677015404","taxonomy=category":"Parken New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/park-icon.png"},"id":955,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/park-icon.png","name":"Parken","id":"3","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Brooklyn Bridge Park, aan de voet van de beroemde brug","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"brooklyn bridge park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/11/brooklyn-bridge-en-park-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Brooklyn Bridge Park, aan de voet van de beroemde brug</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"334 Furman St, Brooklyn, NY 11201, Verenigde Staten","location":{"lat":"40.69914959999999","state":"New York","country":"Verenigde Staten","lng":"-73.9976004","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/brooklyn-bridge-park-new-york-city/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"25px\"][vc_custom_heading text=\"Verken het Brooklyn Bridge Park in New York\" font_container=\"tag:h2|font_size:45|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"En geniet van de verschillende uitzichten\" font_size=\"50\" line_height=\"50\" font_color=\"#282828\"][vc_column_text]Het uitzicht over de skyline van Manhattan is toch wel een van de publiekstrekkers in het Brooklyn Bridge Park. Zoals de naam al zegt, het park bij de <a href=\"https://www.heyusa.com/nl/brooklyn-bridge-park-new-york-city/\">Brooklyn Bridge</a>. Het gebied is vrij recent het Brooklyn Bridge Park geworden nadat het lange tijd dienst deed als vrachthaven. Pas in 2002 kwam de financiering rond en konden er plannen gemaakt worden voor een publiek park onder de Brooklyn Bridge. In de jaren die volgende werden de verschillende pieren aangelegd, het Empire Fulton Ferry en Jane\u2019s Carousel werden geopend. Inmiddels is het een volwaardig park die het bezoeken waard is en ook wanneer je er al geweest bent, want ook in de toekomst liggen er allemaal plannen op de stapel. Benieuwd naar het Brooklyn Bridge Park? Lees dan snel onze tips![/vc_column_text][vc_empty_space height=\"100px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"50px\"][vc_column_text]\r\n\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_custom_heading text=\"Enkele highlights in het Brooklyn Bridge Park\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"20114\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Jane's Carousel\" font_container=\"tag:h3|font_size:25|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Deze vintage carousel staat al sinds 1984 te schitteren aan de waterzijde in het Brooklyn Bridge Park. Ooit gebouwd door Toboggan Company uit Philadelphia in 1922 en door <a href=\"https://www.heyusa.com/nl/new-york/dumbo/\" target=\"_blank\" rel=\"noopener noreferrer\">DUMBO</a>-artiest Jane Walentas twee jaar lang gerestaureerd. In het carousel vind je 48 paarden in rijen van drie met twee koetsen en meer dan 1200 lampjes. Tegenwoordig is er een \u2018paviljoen\u2019 van glas omheen gebouwd en de combinatie van moderne architectuur en het vintage carousel is er een om niet te missen.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"20103\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Pier 2\" font_container=\"tag:h3|font_size:25|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In de zomermaanden is het Brooklyn Bridge Park sowieso al een fijne plek om te vertoeven. Een heerlijk windje vanaf het water en het uitzicht zorgen ervoor dat het een populaire plek is. Op bepaalde dagen in de zomer kun je bij <a href=\"https://www.brooklynbridgepark.org/things-to-do/kayaking/\" target=\"_blank\" rel=\"noopener noreferrer\">Pier 2 gratis kajakken</a>. Een aanrader, want kajakken met uitzicht op het Vrijheidsbeeld en skyline is een onvergetelijke ervaring.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"11081\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Time Out Market\" font_container=\"tag:h3|font_size:25|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Genoeg leuke <a href=\"https://www.heyusa.com/nl/food-markets-new-york/\">foodmarkets in New York</a>. Een daarvan is Time Out Market gevestigd aan het Brooklyn Bridge Park. Het leuke aan een foodmarket is dat er verschillende restaurants een vestiging hebben. Zo ook bij Time Out Foodmarket. Het oude pakhuis heeft veel leuke plekjes om te eten.[/vc_column_text][thb_iconbox type=\"left type1\" animation=\"\" icon_image=\"19694\" icon_image_width=\"125\" heading=\"New York expert tip van Marjolein:\" description=\"Ga ook even naar de rooftop van de Time Out Market, vanaf hier heb je een fantastisch uitzicht!\" thb_heading_color=\"#b34a4c\" thb_text_color=\"#282828\" heading_font_size=\"17px\" description_font_size=\"16px\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"20116\" img_size=\"large\" alignment=\"center\"][vc_custom_heading text=\"Pier 6\" font_container=\"tag:h3|font_size:25|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Ook bij Pier 6 in het Brooklyn Bridge Park kun je actief zijn. Er ligt hier een beachvolleybalveld, uniek toch om een keer te doen met de skyline van Manhattan op de achtergrond? Daarnaast is Fornino een goede stop voor een pizza. Net als Iris Cafe voor een koffie of een ontbijt. Vanaf Pier 6 vertrekt ook de <a href=\"https://www.heyusa.com/nl/nyc-ferry/\">New York Ferry</a> in verschillende richtingen.[/vc_column_text][/vc_column_inner][/vc_row_inner][thb_postbackground source=\"size:1|post_type:post|by_id:-13709,-667,1759\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"De pieren van het Brooklyn Bridge Park in het kort:\" font_container=\"tag:h3|font_size:25|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In totaal heeft het Brooklyn Bridge Park 6 pieren:\r\n<ul>\r\n \t<li>Pier 1: pier met veel gras en bankjes voor een uitzicht op de skyline</li>\r\n \t<li>Pier 3: pier met veel groen</li>\r\n \t<li>Pier 4: strand</li>\r\n \t<li>Pier 5: voetbalvelden</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Hoe kom je er?\" font_container=\"tag:h3|font_size:25|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Subway:\r\n<ul>\r\n \t<li>High Street: A | C</li>\r\n \t<li>Clark Street: 2 | 3</li>\r\n \t<li>York Street: F</li>\r\n</ul>\r\nFerry:\r\n<ul>\r\n \t<li>Pier 1</li>\r\n \t<li>Pier 6</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1633532389694{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Blijft altijd prachtig\" font_size=\"55\" line_height=\"60\" font_color=\"#ffffff\"][vc_custom_heading text=\"Het uitzicht op de skyline van Manhattan\" font_container=\"tag:h3|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"90\" enable_mobile=\"parallax-enable-mobile\" image=\"8889\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"100%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"20101\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Lente &amp; zomer in het park\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">De gehele zomer worden er allerlei events georganiseerd in het Brooklyn Bridge Park. Van culturele activiteiten, recreatie-activiteiten tot educatieve events, er is genoeg te beleven in de zomer. Voor iedere leeftijd staat er wel iets op het programma.</p>\r\n[/vc_column_text][thb_iconbox type=\"left type1\" animation=\"\" icon_image=\"19694\" icon_image_width=\"125\" heading=\"New York expert tip van Marjolein:\" description=\"Stap in een kajak voor een ultieme ervaring!\" thb_heading_color=\"#b34a4c\" thb_text_color=\"#282828\" heading_font_size=\"17px\" description_font_size=\"16px\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"20104\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Herst &amp; winter in het park\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Het park is een stuk minder druk in de winter. De vele buitenactiviteiten zijn niet meer mogelijk en daardoor komen er minder mensen richting het Brooklyn Bridge Park. Het uitzicht op Manhattan veranderd natuurlijk niet en dat is nog steeds een goede reden om toch de kou te trotseren en richting het Brooklyn Bridge Park te gaan.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1678194198432{padding-top: 100px !important;padding-bottom: 100px !important;background-color: #ffffff !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"100%\"][vc_row_inner content_placement=\"middle\"][vc_column_inner width=\"1/2\"][vc_single_image image=\"15148\" img_size=\"large\" onclick=\"custom_link\" img_link_target=\"_blank\" link=\"Oekra\u00efne\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Op zoek naar nog meer leuke plekken in New York?\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:300%20light%20regular%3A300%3Anormal\"][vc_custom_heading text=\"Check dan onze reisgidsen over New York &amp; Brooklyn\" font_container=\"tag:div|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"15px\"][vc_column_text]Klaar om te vertrekken? Ontdek New York en Brooklyn als een \u00e9chte New Yorker met onze unieke reisgidsen![/vc_column_text][thb_button link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fwebshop%2Fhallo-reisgidsen%2F|title:Bestel%20een%20reisgids\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Foto's van het Brooklyn Bridge Park\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][thb_image_slider images=\"20101,20102,9708,8890\"][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York\" font_container=\"tag:div|font_size:50|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:4009,955,1606,630\"][/vc_column][/vc_row]","post_title":"Brooklyn Bridge Park, aan de voet van de beroemde brug","post_link":"https://www.heyusa.com/nl/brooklyn-bridge-park-new-york-city/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"brooklyn bridge park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/11/brooklyn-bridge-en-park-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Parken New York","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1718108035:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%_hide_featured%":null,"%inline_featured_image%":"0","%_yoast_wpseo_metadesc%":"Het Brooklyn Bridge Park in New York is een aanrader om te bezoeken vanwege het uitzicht op Manhattan. Tips voor het Brooklyn Bridge Park.","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Brooklyn Bridge Park in New York","%_yoast_wpseo_title%":"%%title%% in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_linkdex%":"72","%_wpgmp_location_address%":"334 Furman St, Brooklyn, NY 11201, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.69914959999999","%_wpgmp_metabox_longitude%":"-73.9976004","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_thumbnail_id%":"20100","%_wpb_shortcodes_custom_css%":".vc_custom_1633532389694{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1678194198432{padding-top: 100px !important;padding-bottom: 100px !important;background-color: #ffffff !important;}","%_yoast_indexnow_last_ping%":"1718108053","%_last_editor_used_jetpack%":"classic-editor","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","%_yoast_wpseo_primary_category%":"","taxonomy=category":"Parken New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/park-icon.png"},"id":910,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/park-icon.png","name":"Parken","id":"3","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Roosevelt Island","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Roosevelt Island\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/11/Roosevelt-Island-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Roosevelt Island</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Roosevelt Island, New York City, New York 10044, Verenigde Staten","location":{"lat":"40.76050310000001","city":"New York City","state":"New York","country":"Verenigde Staten","lng":"-73.9509934","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/roosevelt-island-new-york-city/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"25px\"][vc_custom_heading text=\"Roosevelt Island in New York\" font_container=\"tag:h2|font_size:45|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Eiland in de East River tussen Manhattan &amp; Queens\" font_container=\"tag:p|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"100px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Blackwell Island Light\" font_container=\"tag:h2|font_size:25|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Roosevelt Island Lighthouse\" font_container=\"tag:h3|font_size:20|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Wanneer je het eiland rondloopt, vind je aan het uiteinde van het eiland een Gotische vuurtoren uit 1872. De vuurtoren is ontworpen door dezelfde architect als St. Patricks Cathedral: James Renwick. De vijftien meter hoge toren werd gebouwd door de gevangen die destijds in de gevangenis zaten. Sinds 1940 wordt de vuurtoren niet meer gebruikt, maar blijft het nog wel het bezoeken waard.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Four Freedoms Park\" font_container=\"tag:h2|font_size:25|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In 2012 werd het Four Freedoms Park geopend op Roosevelt Island, een project dat in 1974 al gestart was maar niet van de grond kwam doordat architect Louis Kahn overleed. In het park staat een memorial voor Franklin D. Roosevelt en vinden tussen mei en oktober allerlei evenementen plaats. En je hebt een fantastisch uitzicht over het vuurwerk op 4 juli.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Roosevelt Island Tramway\" font_container=\"tag:h2|font_size:25|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De route naar Roosevelt Island in New York is een van de hoogtepunten die je zeker niet mag missen. Je kunt namelijk met de <a href=\"https://www.heyusa.com/nl/new-york/roosevelt-island-tram/\" target=\"_blank\" rel=\"noopener\">Rooseveld Island Tram</a> het water oversteken. Het uitzicht op de skyline is fenomenaal en daarbij ook een unieke ervaring. Je kunt vanaf <a href=\"https://www.heyusa.com/nl/new-york/midtown-manhattan/\" target=\"_blank\" rel=\"noopener noreferrer\">Midtown Manhattan</a> met je metro card via de kabelbaan naar de overkant.[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_column_text]\r\n\r\n[/vc_column_text][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"100%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"794\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"LENTE &amp; ZOMER\" heading_tag=\"p\" main_heading_color=\"#000000\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Roosevelt Island wordt steeds populairder onder toeristen. Steeds meer mensen weten de kabelbaan te vinden die ze naar het eiland brengt. Met mooi weer kun je plaatsnemen op een van de vele bankjes met uitzicht op de East River en de skyline van Manhattan bekijken. In de zomermaanden worden er diverse evenementen georganiseerd zoals het <a href=\"https://rioc.ny.gov/372/Roosevelt-Island-Summer-Outdoor-Movie-Se\" target=\"_blank\" rel=\"noopener noreferrer\">Roosevelt Island Summer Outdoor Movies Series</a>. In juni vindt bijvoorbeeld Roosevelt Island Day plaats en daarnaast is het eiland een goede plek voor het vuurwerk op 4 juli.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"793\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"WINTER &amp; KERST\" heading_tag=\"p\" main_heading_color=\"#000000\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In de winter is het een stukje frisser op het eiland dan in Manhattan zelf. De wind heeft hier redelijk vrij spel en maakt het waarschijnlijk net iets kouder. Toch is dat geen reden om het eiland niet te bezoeken. Je kunt prima een wandeling maken rond het eiland om zo te genieten van de skyline van de Manhattan en Queens.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Uniek ritje door de lucht\" font_container=\"tag:div|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Met de kabelbaan\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"1749\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York\" font_container=\"tag:div|font_size:50|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:1747,1559,557,520\"][/vc_column][/vc_row]","post_title":"Roosevelt Island","post_link":"https://www.heyusa.com/nl/roosevelt-island-new-york-city/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Roosevelt Island\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/11/Roosevelt-Island-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Parken New York","post_tags":"","%_edit_last%":"1","%_edit_lock%":"1691424644:1","%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%_hide_featured%":null,"%_thumbnail_id%":"5367","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Roosevelt Island in New York","%_yoast_wpseo_title%":"%%title%% in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Roosevelt Island in New York is een eiland tussen Manhattan en Queens. Ga met de Roosevelt Island kabeltram en ontdek het eiland.","%_yoast_wpseo_linkdex%":"78","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"Roosevelt Island, New York City, New York 10044, Verenigde Staten","%_wpgmp_location_city%":"New York City","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.76050310000001","%_wpgmp_metabox_longitude%":"-73.9509934","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wpb_shortcodes_custom_css%":".vc_custom_1582906882917{padding-top: 25px !important;}","%_yoast_indexnow_last_ping%":"1691424437","%_last_editor_used_jetpack%":"classic-editor","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_primary_category%":"","taxonomy=category":"Parken New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/park-icon.png"},"id":791,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/park-icon.png","name":"Parken","id":"3","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Museum of the City of New York","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Museum of the City of New York\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/11/museum-of-the-city-of-new-york-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Museum of the City of New York</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1220 5th Ave, New York, NY 10029, Verenigde Staten","location":{"lat":"40.7924939","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.95190889999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/museum-of-the-city-of-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text]<strong>Een museum over de stad New York vind je aan het einde van Museum Mile op 5th avenue. In The Museum of the City of New York maak je kennis met de geschiedenis van de stad New York. Het museum heeft een enorme collectie met meer dan 1,5 miljoen objecten. Niet alleen schilderijen, maar ook objecten zorgen ervoor dat je meer te weten komt over de stad New York. En daarnaast krijg je soms een unieke inkijk in woonkamers van belangrijke figuren uit de New Yorkse geschiedenis.</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Upper East Side | 1220 5th Avenue - 103rd Street\"][thb_iconlist icon=\"fas fa-subway\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"103rd Street | 6\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.viator.com%2Ftours%2FNew-York%2FMuseum-of-the-City-of-New-York-General-Admission%2Fd5560-118840P1%3Fpid%3DP00074479%26mcid%3D42383%26medium%3Dlink%26campaign%3Dmuseumofthecityofnyc\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Het museum over de stad New York\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Vlakbij <a href=\"https://www.heyusa.com/nl/new-york/central-park/\" target=\"_blank\" rel=\"noopener noreferrer\">Central Park</a> vind je het 'stadsmuseum' van New York In het Museum of the City of New York maak je kennis met alle facetten van de stad New York. Denk aan Broadway, woninginrichtingen, maar ook aan hoe de stad uiteindelijk is ontstaan.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Leer alles over de stad New York\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Duik in de geschiedenis van de stad\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"10643\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"In het Museum of the City of New York\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Timescapes\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Deze award winnende documentaire laat je in 28 minuten kennis maken met the Big Apple. Hoe werd New York, met destijds slechts een paar honderd Europeanen, de stad die het tegenwoordig is. Door middel van tekeningen, kaarten, foto\u2019s en schilderijen word je meegenomen in het verhaal van de beginperiode van New York naar de metropolis die het nu is. Iedere veertig minuten kun je Timescapes bekijken.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Theater collectie\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Ben liefhebber van de Broadway shows in New York? Dan is het Museum of the City of New York het bezoeken waard! In het museum staan objecten van theatershows die opgevoerd zijn sinds 1785. Onder andere scripts, tekeningen, artikelen, contracten, kostuums en foto\u2019s geven een beeld van de Broadway shows van afgelopen jaren.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Meubels en decoratieve kunst\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">De meubelcollectie van het museum toont de stijlen in meubelproductie vanaf de late 17e eeuw tot het begin van de 20e eeuw. De meubelproductie in New York was een belangrijke business en de collectie laat zien hoe de stijlen meegingen met een stad die veranderde. Onder de collectie bevinden zich werken van toonaangevende makers als John Henry Betler and Company en de Herter Brothers. Ook de keramiek- en glaswerk collectie zijn belangrijke pijlers die de geschiedenis van New York laten zien.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Kom meer te weten of New York\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Aanrader voor New York liefhebbers\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"10645\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ook leuk in New York City:\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][fullwidth_row][thb_postgrid columns=\"4\" source=\"post_type:post|by_id:1594,1312,408,1559\"][/vc_column][/vc_row]","post_title":"Museum of the City of New York","post_link":"https://www.heyusa.com/nl/museum-of-the-city-of-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Museum of the City of New York\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/11/museum-of-the-city-of-new-york-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1667999077:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"16","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Museum of the City of New York","%_yoast_wpseo_metadesc%":"Een van de musea waar je informatie over New York zelf kunt vinden is het Museum of the City of New York. Tips voor je bezoek.","%_yoast_wpseo_linkdex%":"74","%_wpgmp_location_address%":"1220 5th Ave, New York, NY 10029, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7924939","%_wpgmp_metabox_longitude%":"-73.95190889999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_thumbnail_id%":"10642","%_yoast_indexnow_last_ping%":"1677015418","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Musea New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":1612,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Het grootste museum van New York: The Metropolitan Museum of Art","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The MET\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/11/THE-MET2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Het grootste museum van New York: The Metropolitan Museum of Art</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1000 5th Ave, New York, NY 10028, Verenigde Staten","location":{"lat":"40.7794366","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.963244","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/metropolitan-museum-of-art-the-met-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Twee miljoen kunstwerken in The MET\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<strong>The Metropolitan Museum - The MET in New York is het grootste museum van de stad. Het wordt vergeleken met het Rijksmuseum in Amsterdam en het Louvre in Parijs. Net als de eerder genoemde musea heeft The MET een hele uitgebreide collectie. Net als dat je alle kunstwerken in het Louvre onmogelijk kunt zien tijdens een bezoek, geldt dat ook voor The MET. Er is zoveel te zien dat je onmogelijk alles in een bezoek kunt stoppen. Er zijn meer dan twee miljoen kunstwerken in de permanente collectie te zien in The MET. Kunstwerken van over de hele wereld, uit de Klassieke Oudheid, werken van Europese meesters en Amerikaanse Kunst, in The MET is voor iedereen wel iets te zien.</strong>\r\n\r\n<a href=\"https://www.getyourguide.com/new-york-city-l59/meet-the-met-small-group-metropolitan-museum-tour-t48274/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=metnycinclrondleidingtekst\" target=\"_blank\" rel=\"noopener\">Bestel hier je tickets voor The MET inclusief rondleiding</a>.[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Midtown Manhattan | 1000 5th Avenue\"][thb_iconlist icon=\"fas fa-subway\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"86 Street Station | 4 | 5 | 6\"][vc_empty_space height=\"25px\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Voor iedere kunstliefhebber wel iets\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Als je een museum moet kiezen tijdens je bezoek aan New York, dan is The Metropolitan Museum of Art \u2013 The MET wel een aanrader. Er zijn zoveel kunstwerken te zien dat je wel even zoet bent, maar er is ook voor iedere kunstliefhebber wel iets te zien. En vergeet het fijne dakterras van The MET niet.</p>\r\n[/vc_column_text][thb_iconbox type=\"left type1\" animation=\"\" icon_image=\"19694\" icon_image_width=\"125\" heading=\"New York expert tip van Marjolein:\" description=\"Heb je meer activiteiten en bezienswaardigheden op de planning in New York? Bekijk dan eens of een Voordeelpas een optie is voor je bezoek.\" thb_heading_color=\"#b34a4c\" thb_text_color=\"#282828\" heading_font_size=\"17px\" description_font_size=\"16px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Bekijk het grootste museum van New York\" font_size=\"55\" line_height=\"60\" font_color=\"#ffffff\"][vc_custom_heading text=\"Enorme collectie met kunstwerken\" font_container=\"tag:h3|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"3500\"][vc_empty_space height=\"350px\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Een aantal tips voor het The Metropolitan Museum of Art\" font_container=\"tag:h2|font_size:50|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/4\"][vc_single_image image=\"7236\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Europese kunstwerken\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Zo\u2019n 1700 schilderijen van Europese meesters zijn te bewonderen in The MET. In deze collectie zitten kunstwerken van Nederlandse meesters als Rembrandt, van Ruysdael en Hobbema. Naast de schilderijen zijn er ook sculpturen van Europese kunstenaars te bezichtigen. In totaal bevat deze enorme collectie zo\u2019n 50.000 kunstwerken van de 15e tot de vroege 20e eeuw.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][vc_single_image image=\"7235\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Moderne en hedendaagse kunst\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Een andere grote collectie in The MET is die van de hedendaagse en moderne kunst. In deze collectie vallen zo\u2019n 13.000 schilderijen die grotendeels door Europese en Amerikaanse schilders zijn gemaakt. Schilderijen die je niet mag missen zijn die van Picasso (Gertrude Stein), Jasper John\u2019s (White Flag) en Jackson Pollock (Autumn Rhythm). In 2013 is deze collectie uitgebreid door een gift van cosmetica gigant Leonard Lauder.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][vc_single_image image=\"20123\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Egyptische kunst\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]Met meer dan 30.000 voorwerpen is de afdeling Egyptische kunst er een om niet te missen. Veel voorwerpen zijn van artistiek, historische en cultureel belang. De meesten dateren van ongeveer 300.000 voor Christus tot de 4e eeuw na Christus. Een groot deel van de collectie is afkomstig van een museum uit Egypte.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][vc_single_image image=\"3499\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Dakterras van het MET\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]The Roof Garden is een van de mogelijkheden om wat te eten of te drinken onder het genot van een prachtig uitzicht over <a href=\"https://www.heyusa.com/nl/new-york/central-park/\" target=\"_blank\" rel=\"noopener noreferrer\">Central Park</a> en Manhattan. Op de zuidwesthoek van het gebouw zit dit cafe dat vooral op vrijdag- en zaterdagavond enorm populair is. Ieder jaar zijn er verschillende exposities met een kunstenaar te bekijken. The Roof Garden wordt gezien als een van de beste plekken in New York om de skyline te bekijken.[/vc_column_text][/vc_column_inner][/vc_row_inner][ult_buttons btn_title=\"Bestel je tickets voor entree inclusief rondleiding\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fmeet-the-met-small-group-metropolitan-museum-tour-t48274%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dmetnycinclrondleiding|target:_blank\" btn_align=\"ubtn-center\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Voordeelpassen New York\" font_size=\"55\" line_height=\"60\" font_color=\"#ffffff\"][vc_custom_heading text=\"Bekijk je voordeel en vergelijk de passen\" font_container=\"tag:h3|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ult_buttons btn_title=\"Lees meer\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fvoordeelpassen-new-york%2F|title:Voordeelpassen%20New%20York|target:_blank\" btn_align=\"ubtn-center\" btn_size=\"ubtn-small\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:25px;\" btn_line_height=\"desktop:30px;\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"10052\"][vc_empty_space height=\"350px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York\" font_container=\"tag:div|font_size:50|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:1484,520,1647,772\"][/vc_column][/vc_row]","post_title":"Het grootste museum van New York: The Metropolitan Museum of Art","post_link":"https://www.heyusa.com/nl/metropolitan-museum-of-art-the-met-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The MET\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/11/THE-MET2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1718110987:2","%_edit_last%":"2","%_wpb_vc_js_status%":"true","%post-primary-category%":"16","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"The MET\"]","%_yoast_wpseo_focuskw%":"The Metropolitan Museum of Art","%_yoast_wpseo_metadesc%":"Het grootste museum vind je in New York: The Metropolitan Museum of Art \u2013 The MET. Tips voor je bezoek aan het The Metropolitan Museum of Art","%_yoast_wpseo_linkdex%":"73","%_yoast_wpseo_content_score%":"90","%_wpgmp_location_address%":"1000 5th Ave, New York, NY 10028, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7794366","%_wpgmp_metabox_longitude%":"-73.963244","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_thumbnail_id%":"3501","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1718110998","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","%_yoast_wpseo_primary_category%":"","taxonomy=category":"Musea New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":1594,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Bryant Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Bryant Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/07/bryantpark-nieuw-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Bryant Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"New York City, New York 10018, Verenigde Staten","location":{"lat":"40.7535965","city":"New York City","state":"New York","country":"Verenigde Staten","lng":"-73.9832326","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/bryant-park-new-york-city/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"25px\"][vc_custom_heading text=\"Bryant Park in New York\" font_container=\"tag:h2|font_size:45|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Bryant Park - Na Central Park het meest bezochte park van Manhattan\" font_container=\"tag:p|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][ultimate_video u_video_url=\"https://www.youtube.com/watch?v=2KMNuyV_Zts\" yt_autoplay=\"\" yt_sugg_video=\"\" yt_mute_control=\"\" yt_modest_branding=\"\" yt_privacy_mode=\"\" play_size=\"75\" enable_sub_bar=\"\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Vele veranderingen in Bryant Park\" font_container=\"tag:h2|font_size:25|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Bryant Park, zoals we het tegenwoordig kennen, bestaat eigenlijk pas sinds 1992 na ruim 4 jaar verbouwingen en restauraties. Sindsdien ligt deze prachtige \u201cachtertuin\u201d achter de eveneens prachtige New York Library aan Fifth Avenue. Het is een groene oase midden in de stad omgeven door hoge wolkenkrabbers.\r\nPas in 1884 werd Bryant Park ingericht als een publiek park. Daarvoor was het enkel een plein, gelegen aan het Croton water reservoir. Sinds de opening heeft Bryant Park meerdere malen een totale nieuwe look gekregen.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Films kijken in de zomermaanden\" font_container=\"tag:h2|font_size:25|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Net als in vele andere <a href=\"https://www.heyusa.com/nl/steden/newyork/parken/\" target=\"_blank\" rel=\"noopener noreferrer\">parken in New York</a>, stroomt in de zomermaanden Bryant Park rond zonsondergang regelmatig vol met filmliefhebbers. <a href=\"https://bryantpark.org/programs/movie-nights\" target=\"_blank\" rel=\"noopener\">Diverse films</a> worden er vertoond in het park. Het enige dat je mee hoeft te nemen is een kleedje, de film is gratis.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Bryant Park Hotel\" font_container=\"tag:h2|font_size:25|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\u00c9\u00e9n van de meest markante gebouw aan Bryant Park is het hedendaagse Bryant Park Hotel, dit neogotische donkerbruine gebouw met gouden punten doet je denken aan brandend houtskool, een lucifer of een chique radiator. Toepasselijk, omdat dit gebouw ontworpen werd voor \u201cThe American Radiator Company\u201d, producent van verwarmingselementen. Tegenwoordig is het een luxe hotel met prachtig uitzicht over Bryant Park.[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_column_text]\r\n\r\n[/vc_column_text][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"100%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"907\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"LENTE &amp; ZOMER\" heading_tag=\"p\" main_heading_color=\"#000000\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:25px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Tegenwoordig en vooral in de zomermaanden krioelt het van de mensen in het park op The Great Lawn. Overal staan er stoelen en tafeltjes waar veel kantoorpersoneel \u2019s middags komt lunchen, terwijl de jongeren in het perfect gemaaide gras liggen. Er zijn enkele kiosken waar je een drankje en een snack kunt kopen. Er is een buitenafdeling van de bibliotheek en in de \u2018leeshoek\u2019 in het park kun je een boek uit de rekken nemen en rustig genieten van het zonnetje.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"906\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"WINTER &amp; KERST\" heading_tag=\"p\" main_heading_color=\"#000000\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:25px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In de wintermaanden wordt Bryant Park omgetoverd tot een groots winters dorp, \u201cBryant Park Winter Village\u201d met een kerstmarkt, schaatsbaan, diverse restaurants en veel winterse gezelligheid. Toegang tot de schaatsbaan is gratis, voor schaatshuur betaal je tussen de $15 en $20 afhankelijk van de periode.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Groene oase\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"In midtown Manhattan\" font_container=\"tag:div|font_size:45|text_align:center\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"905\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York\" font_container=\"tag:div|font_size:50|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"size:4|order_by:rand|post_type:post|categories:14\"][/vc_column][/vc_row]","post_title":"Bryant Park","post_link":"https://www.heyusa.com/nl/bryant-park-new-york-city/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Bryant Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/07/bryantpark-nieuw-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Parken New York","post_tags":"","%_edit_last%":"1","%_edit_lock%":"1633532078:1","%_wpb_vc_js_status%":"true","%post-primary-category%":"13","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%_hide_featured%":null,"%_thumbnail_id%":"904","%_wp_old_date%":"2020-07-07","%inline_featured_image%":"0","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Bryant Park in New York","%_yoast_wpseo_title%":"%%title%% in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Midden in Midtown Manhattan vind je Bryant Park. Benieuwd wat je kunt doen in Bryant Park? Tips voor Bryant Park in New York.","%_yoast_wpseo_linkdex%":"74","%_wpgmp_location_address%":"New York City, New York 10018, Verenigde Staten","%_wpgmp_location_city%":"New York City","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7535965","%_wpgmp_metabox_longitude%":"-73.9832326","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%post_via%":[{"title":"Bryant Park winter: Brittany Petronella / NYC & Company","post_source_url":"nycgo.com"},{"title":"Bryant Park zomer: Will Steacy /NYC & Company","post_source_url":"nycgo.com"},{"title":"","post_source_url":""}],"%_wpb_shortcodes_custom_css%":".vc_custom_1582906882917{padding-top: 25px !important;}","%_yoast_indexnow_last_ping%":"1677015424","taxonomy=category":"Parken New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":903,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Painted Ladies in San Francisco","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Tips voor gratis activiteiten in San Francisco\" width=\"300\" height=\"192\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/11/sanfrancisco-paintedladies-300x192.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Painted Ladies in San Francisco</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"Boottocht van 90 minuten over de Hudson en East River","address":"Steiner St &, Hayes St, San Francisco, CA 94117, Verenigde Staten","location":{"lat":"37.7762528","city":"San Francisco","state":"California","country":"Verenigde Staten","lng":"-122.4327556","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/painted-ladies-san-francisco/","zoom":12,"extra_fields":{"post_excerpt":"Boottocht van 90 minuten over de Hudson en East River","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Painted Ladies\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">De bekendste Painted Ladies zijn te vinden op Steiner Street bij Alamo Square in San Francisco. In de architectuur worden huizen Painted Ladies genoemd wanneer de huizen in een Victoriaanse stijl in drie of meer kleuren geverfd zijn. De term stamt op 1978 toen hij werd gebruikt door Elizabeth Pomada en Michael Larsen in hun boek Painted Ladies.</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Gratis[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Tips voor een bezoek aan de Painted Ladies van San Francisco\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">De Painted Ladies in San Francisco zijn een van de meest gefotografeerde plekken in de stad. Vanaf Alamo Square heb je niet alleen de gekleurde huizen op de foto, de wolkenkrabbers van <a href=\"https://www.heyusa.com/nl/san-francisco/downtown-san-francisco/\" target=\"_blank\" rel=\"noopener noreferrer\">downtown San Francisco</a> zorgen voor een fotogenieke plek. Hierdoor krijg je een mooie contrast tussen de huizen in Victoriaanse stijl en de nieuwe wolkenkrabbers in downtown San Francisco.</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Alamo Square\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_custom_heading text=\"Kleurrijke huizen van San Francisco\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"3264\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Painted Ladies in San Francisco\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In San Francisco zijn naast de bekendste Painted Ladies op Steiner Street nog meer huizen te vinden die gebouwd zijn in Victoriaanse en Edwardiaanse stijl. Zo'n 48.000 huizen werden tussen 1849 en 1915 in dezelfde stijl gebouwd. Tijdens de aardbeving van 1906 werden redelijk wat van deze huizen verwoest. Na de beide oorlogen werden veel van de overige huizen in diverse kleuren geschilderd. De rij huizen op Steiner Street wordt ook wel Postcard Row genoemd of soms The Seven Sisters en is het bekendste voorbeeld van Painted Ladies.\r\n\r\nOok in andere steden zijn er Painted Ladies: Baltimore, St. Louis, Cincinnati en Toledo.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Serie Full House\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De populaire sitcom van de jaren '90 <a href=\"https://www.imdb.com/title/tt0092359/\" target=\"_blank\" rel=\"noopener\">Full House</a> zorgde voor bekendheid aan de Painted Ladies in San Francisco. In de opening credits van de serie werd een shot gebruikt van de gekleurde huizen. Hoewel het lijkt alsof de gebeurtenissen van de familie Tanner zich afspeelden in de huizen werd de serie grotendeels opgenomen in een studio. En stiekem bevond het huis in de opening scene zich op 1709 Broderick Street en niet in Postcard Row.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Enjoy the view!\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_custom_heading text=\"Uitzicht op de kleurrijke huizen van San Francisco\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"3263\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk in San Francisco:\" font_container=\"tag:div|font_size:50|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:2562,2421,2275,2351\"][/vc_column][/vc_row]","post_title":"Painted Ladies in San Francisco","post_link":"https://www.heyusa.com/nl/painted-ladies-san-francisco/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Tips voor gratis activiteiten in San Francisco\" width=\"300\" height=\"192\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/11/sanfrancisco-paintedladies-300x192.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden San Francisco","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1665476080:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"50","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_yoast_wpseo_focuskw%":"Painted Ladies","%_yoast_wpseo_title%":"%%title%% San Francisco %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een van de meest gefotografeerde locaties in San Francisco zijn de Painted Ladies op Alamo Square, bekend van de serie Full House.","%_yoast_wpseo_linkdex%":"75","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Painted Ladies San Francisco\"]","%inline_featured_image%":"0","%_thumbnail_id%":"2548","%_wpgmp_location_address%":"Steiner St &, Hayes St, San Francisco, CA 94117, Verenigde Staten","%_wpgmp_location_city%":"San Francisco","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"37.7762528","%_wpgmp_metabox_longitude%":"-122.4327556","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015428","taxonomy=category":"Bezienswaardigheden San Francisco","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":2567,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Ferry Building San Francisco","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Ferry Building\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/Ferry-Building-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Ferry Building San Francisco</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1 Ferry Building, San Francisco, CA 94111, Verenigde Staten","location":{"lat":"37.7958379","city":"San Francisco","state":"California","country":"Verenigde Staten","lng":"-122.3937801","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/ferry-building-san-francisco/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Ferry Building in San Francisco\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Ferry Building in San Francisco is de plek waar de veerboten vertrekken naar onder andere San Francisco Bay. Daarnaast is het een plek waar de Ferry Building Marketplace zich bevind. Een culinaire ervaring in een historische architectonische landmark.\u00a0</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Gratis[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Bezoek de Ferry Building Market Place\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">The <a href=\"https://www.ferrybuildingmarketplace.com/\" target=\"_blank\" rel=\"noopener\">Ferry Building Marketplace</a> is een plek met vele kleine foodcourts waar je terecht kunt voor koffie, lekkere tussendoortjes en boerenkaas. Je kunt hier een lunch to go meenemen van een van de foodcourts of gezellig bij een van de vele restaurants plaatsnemen. Er bevinden zich een aantal goede restaurants in The Ferry Building Marketplace.</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Ferry Building\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][vc_custom_heading text=\"De kenmerkende klok\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"3300\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Stukje geschiedenis van The Ferry Building\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]The Ferry Building werd voor het eerst geopend in 1898. Het was een van de grootste projecten in San Francisco. Gebouwd in Beaux Art Style en ge\u00efnspireerd door klassieke Europese architectuur, is de klok het meest opvallende aan het gebouw. De plek werd een transportatie hub voor ongeveer 50.000 forenzen, in de hoogtijdagen \u00e9\u00e9n van de drukste terminals ter wereld. Door de komst van de <a href=\"https://www.heyusa.com/nl/san-francisco/golden-gate-bridge/\" target=\"_blank\" rel=\"noopener\">Golden Gate Bridge</a> werd de ferry in eerste instantie overbodig.\r\n\r\nIn 2003 werd het gebouw heropend. The Ferry Marketplace opende in het gebouw en de ferry's begonnen weer te varen door de toenemende drukte.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Farmers Market &amp; Outdoor Vendors\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Op dinsdag, donderdag en zaterdag vind je bij de Ferry Building The Ferry Plaza Farmers Market. Bij vele kraampjes kun je verse, lokale producten kopen. Er is veel ambachtelijk aanbod op de Farmers Market. Ook zijn er regelmatig demonstraties te zien. Wekelijks komen er zo'n 40.000 bezoekers op de markt af. De donderdag staat in het teken van streetfood en op zaterdag zijn er een aantal lokale restaurants om hun menu te presenteren.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Ferry Market\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][vc_custom_heading text=\"Gezelligheid bij de Farmers Market\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"3299\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk in San Francisco\" font_container=\"tag:div|font_size:50|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:2567,2275,2431,2534\"][/vc_column][/vc_row]","post_title":"Ferry Building San Francisco","post_link":"https://www.heyusa.com/nl/ferry-building-san-francisco/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Ferry Building\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/Ferry-Building-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden San Francisco","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1665476032:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"50","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_yoast_wpseo_focuskw%":"Ferry Building","%_yoast_wpseo_title%":"Ferry Building in San Francisco %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Niet alleen is Ferry Building de plek waar de ferry's vertrekken, het is een leuke bezienswaardigheid in San Francisco om te bezoeken.","%_yoast_wpseo_linkdex%":"77","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Ferry Building San Francisco\"]","%inline_featured_image%":"0","%_thumbnail_id%":"3278","%_wpgmp_location_address%":"1 Ferry Building, San Francisco, CA 94111, Verenigde Staten","%_wpgmp_location_city%":"San Francisco","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"37.7958379","%_wpgmp_metabox_longitude%":"-122.3937801","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015430","taxonomy=category":"Bezienswaardigheden San Francisco","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":2562,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Walt Disney Family Museum San Francisco","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Walt Disney Family Museum\" width=\"300\" height=\"175\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/11/Walt-Disney-2-300x175.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Walt Disney Family Museum San Francisco</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"104 Montgomery St, San Francisco, CA 94129, Verenigde Staten","location":{"lat":"37.8013564","city":"San Francisco","state":"California","country":"Verenigde Staten","lng":"-122.45852","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/walt-disney-family-museum-san-francisco/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Walt Disney Family Museum\" font_container=\"tag:div|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<strong>Het Walt Disney Family Museum in San Francisco staat in het teken van de legendarische Walt Disney. Het museum wordt beheerd door de Disney familie zelf. Kom het verhaal achter de grote man van Disney bekijken in het Walt Disney Family Museum.</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"104 Montgomery Street\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"BOEK JE TICKETS\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fsan-francisco-l61%2Fthe-walt-disney-family-museum-general-admission-ticket-t207231%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dheyusa_website|title:Walt%20Disney%20Family%20Museum|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Het verhaal van Walt Disney\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In dit museum komt het verhaal van Walt Disney tot leven. Ontdek waarom hij zijn eerste pretpark opende of hoe hij begon met tekenen. In het museum bevinden zich diverse tentoonstellingen die het leven van Walt Disney vertellen. Een museum voor de liefhebbers van Disney.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Tof museum voor Disney fans!\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Uniek inkijkje in het leven van Walt Disney\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"BOEK JE TICKETS\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fsan-francisco-l61%2Fthe-walt-disney-family-museum-general-admission-ticket-t207231%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dheyusa_website|title:Walt%20Disney%20Family%20Museum|target:_blank\" btn_align=\"ubtn-center\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"2541\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Wat mag je niet missen in het Walt Disney Family Museum\" font_container=\"tag:h2|font_size:50|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"2542\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Maquettes 1e Disney Park\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]In het museum vind je een maquette van het eerste Disney park. Disney wilde een plek cre\u00ebren voor zowel volwassenen als kinderen. Het eerste park opende in 1955 en sindsdien zijn er vele gevolgd.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"2543\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Fantasia Theater\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Een theater met Disney films kan natuurlijk niet ontbreken in een museum over Walt Disney. In het op Fantasia ge\u00efnspireerde theater worden dagelijks Disney films vertoond.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"2544\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Levensverhaal Disney\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]In tien verschillende tentoonstelling wordt het leven van Walt Disney getoond. Van de vroege jaren, de stap naar Hollywood, nieuwe technieken, het openen van Disneyland tot aan zijn dood. Iedere galerij belicht een apart deel van het leven van Disney.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Alcatraz\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Beroemdste (ex) gevangenis van Amerika\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Falcatraz-san-francisco%2F|title:Alcatraz\" btn_align=\"ubtn-center\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"3268\"][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"Walt Disney Family Museum San Francisco","post_link":"https://www.heyusa.com/nl/walt-disney-family-museum-san-francisco/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Walt Disney Family Museum\" width=\"300\" height=\"175\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/11/Walt-Disney-2-300x175.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea San Francisco","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1667979019:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"50","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_yoast_wpseo_metadesc%":"Het Walt Disney Family Museum San Francisco staat in het teken van Walt Disney. Tips voor je bezoek aan het Walt Disney Family Museum.","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Walt Disney Museum\"]","%_yoast_wpseo_focuskw%":"Walt Disney Family Museum San Francisco","%_yoast_wpseo_title%":"Walt Disney Family Museum San Francisco%%page%% %%sep%% %%sitename%%","%_yoast_wpseo_linkdex%":"67","%standard-featured-credit%":"Foto Theater: Jim Smith- courtesy The Walt Disney Family Museum","%post_via%":[{"title":"Foto Theater: Jim Smith- courtesy The Walt Disney Family Museum","post_source_url":"waltdisney.org"},{"title":"Header foto: Ric Miller - courtesy The Walt Disney Family Museum","post_source_url":"https://www.waltdisney.org/"},{"title":"Overige fotos: Caitlin Moneypenny-Johnston courtesy The Walt Disney Family Museum","post_source_url":"waltdisney.org"}],"%_thumbnail_id%":"2540","%_wpgmp_location_address%":"104 Montgomery St, San Francisco, CA 94129, Verenigde Staten","%_wpgmp_location_city%":"San Francisco","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"37.8013564","%_wpgmp_metabox_longitude%":"-122.45852","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%inline_featured_image%":"0","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1677015432","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Musea San Francisco","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":2534,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"California Academy of Sciences San Francisco","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Californa Academy of Sciences\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/11/California-academy-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">California Academy of Sciences San Francisco</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"55 Music Concourse Dr, San Francisco, CA 94118, Verenigde Staten","location":{"lat":"37.76986459999999","city":"San Francisco","state":"California","country":"Verenigde Staten","lng":"-122.4660947","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/california-academy-of-sciences-san-francisco/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"California Academy of Sciences San Francisco\" font_container=\"tag:div|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<strong>In het <a href=\"https://www.heyusa.com/nl/san-francisco/golden-gate-park/\" target=\"_blank\" rel=\"noopener\">Golden Gate Park</a> vind je het California Academy of Sciences, een research instituut en museum gericht op de natuur. Het is een van de grootste museum of natural history in de wereld. In het museum vind je onder meer aquaria, een planetarium en diverse tentoonstellingen. De oorsprong van het museum stamt uit 1853 waarna het museum langzaam uitgroeide met allerlei diverse hallen met tentoonstellingen.</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"55 Music Concourse Dr.\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"BOEK JE TICKETS\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fcalifornia-academy-of-sciences-l5125%2Fskip-the-line-california-academy-of-sciences-entrance-t8481%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dcaliforniaacademyofsciencesbanner|title:California%20Academy%20of%20Sciences|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Enorme collectie specimens\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Het California Academy of Sciences is een van de grootste natuurhistorische musea ter wereld. In de collectie vind je meer dan 20 miljoen specimens. Er bevinden zich meerdere hallen in het museum met tentoonstellingen. In de kelder vind je een aquarium waar een Filipijnse koraalrif is nagebootst.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"California Academy of Sciences San Francisco\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\" margin_design_tab_text=\"\"][/ultimate_heading][ultimate_heading main_heading=\"Indrukwekkend en interactief museum\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"3271\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Wat mag je niet missen in het California Academy of Sciences\" font_container=\"tag:h2|font_size:50|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"7925\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Aquaria\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]In de kelder kun je terecht voor diverse aquaria. In het Philippine Coral Reef is het koraalrif van de Filipijnen nagebootst. Er zwemmen diverse soorten vissen in zoals clownsvissen en zeepalingen. Ook bevindt zich in de kelder Water Planet met meer dan 100 aquaria waarin vissen, reptielen en amfibie\u00ebn leven. De laatste trekpleister in de kelder is The Swamp waar een subtropische moeras is nagebootst. Hier leven Amerikaanse alligators en vissen.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"3332\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Regenwoud\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]In een nagebootst regenwoud wandel je in warmte door diverse planten en dieren die onder meer voorkomen in Madagaskar, Costa Rica en het Amazonegebied. Het regenwoud bevindt zich op de begane grond en heeft een prachtige koepel. In een onderwatertunnel kun je tussen de piranha's en anaconda's doorlopen, kortom een unieke ervaring in een nagebootst regenwoud.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"7926\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Natural History Museum\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]In het California Academy of Science is een onderdeel geweid aan natuurhistorisch onderzoek. Vergelijk fossielen en menselijke verwanten met elkaar en ontdek unieke exemplaren in het museum. Dit terwijl je omringd wordt door botten door enkele van de grootste bewoners van de planeet. Zo zie je in dit gedeelte van het museum een skelet van T-Rex van meer dan 25 meter hoog![/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Alcatraz\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Beroemdste (ex) gevangenis van Amerika\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Falcatraz-san-francisco%2F|title:Alcatraz\" btn_align=\"ubtn-center\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"3268\"][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"California Academy of Sciences San Francisco","post_link":"https://www.heyusa.com/nl/california-academy-of-sciences-san-francisco/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Californa Academy of Sciences\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/11/California-academy-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea San Francisco","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1667476871:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"50","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_yoast_wpseo_metadesc%":"Het California Academy of Sciences in San Francisco is een natuurwetenschappelijk museum. Tips voor je bezoek aan California Academy of Sciences.","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"California Academy of Sciences San Francisco","%_yoast_wpseo_title%":"California Academy of Sciences San Francisco%%page%% %%sep%% %%sitename%%","%_yoast_wpseo_linkdex%":"70","%_thumbnail_id%":"3333","%inline_featured_image%":"0","%_wpgmp_location_address%":"55 Music Concourse Dr, San Francisco, CA 94118, Verenigde Staten","%_wpgmp_location_city%":"San Francisco","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"37.76986459999999","%_wpgmp_metabox_longitude%":"-122.4660947","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015435","taxonomy=category":"Musea San Francisco","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":2528,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"San Francisco Museum of Modern Art","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"SF MOMA\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/SF-MOMA-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">San Francisco Museum of Modern Art</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"151 3rd St, San Francisco, CA 94103, Verenigde Staten","location":{"lat":"37.7857182","city":"San Francisco","state":"California","country":"Verenigde Staten","lng":"-122.4010508","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/san-francisco-museum-modern-art/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"25px\"][ultimate_heading main_heading=\"San Francisco Museum of Modern Art\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]<strong>In het San Francisco Museum of Modern Art staat de moderne kunst centraal. Het was het eerste museum aan de Amerikaanse westkust waar liefhebbers van moderne kunst terecht konden. Het museum zit in een opvallend gebouw sinds de grote transformatie en verhuizing naar Third Street en wordt in de volksmond ook wel SFMOMA genoemd, een verwijzing naar het <a href=\"https://www.heyusa.com/nl/new-york-city/museum-of-modern-art-moma/\" target=\"_blank\" rel=\"noopener\">MoMa</a> in New York.</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"151 Third St\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fsan-francisco-l61%2Fentrance-tickets-san-francisco-museum-of-modern-art-moma-t182342%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dmuseum-page|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"\u00c9\u00e9n van de grootste musea in Amerika\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Sinds de verhuizing naar Third Street is het SFMOMA een van de grootste musea in Amerika en misschien wel van de hele wereld. Zeker op het gebied van moderne en hedendaagse kunt is het een toonaangevend museum. Met meer dan 33.000 kunstwerken op 16.000 m2 is het de plek voor kunstliefhebbers.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Toonaangevend museum in Amerika\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"D\u00e9 plek voor kunstliefhebbers van moderne kunst\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"7923\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"3329\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Hedendaagse schilderwerken\" heading_tag=\"h6\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Het SFMOMA staat bekend om de vele kunstwerken van hedendaagse schilders als Jackson Pollock, Henri Matisse en Andy Warhol. In meer dan twintig ruimtes heb je de mogelijkheid kennis te maken met de kunstwerken van beroemde schilders.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"7922\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Rooftop Garden\" heading_tag=\"h6\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]In 2009 opende SFMOMA een dakterras dat het bezoeken waard is. De tuin is ontworpen door Jensen Architects. Op het dakterras zijn openluchtruimtes, een glazen paviljoen en heb je uitzicht op de sculpturen collectie van het museum en de skyline van de stad.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"3330\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Wisselende tentoonstellingen\" heading_tag=\"h6\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Gedurende het jaar zijn er diverse wisselende tentoonstellingen in het SFMOMA. Specifieke thema's en kunstenaars worden in die periode uitgelicht. Zo kon je onder andere een expositie van David Park, Julie Mehretu of Pop, Minimal and figurative art bekijken.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"400px\"][ultimate_heading main_heading=\"Michael Jackson &amp; Bubbles\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\" margin_design_tab_text=\"\"][/ultimate_heading][ultimate_heading main_heading=\"Het beroemde beeld van Jeff Koons in SFMOMA\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_empty_space height=\"400px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"7980\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Lees meer over San Francisco:\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][fullwidth_row][thb_postgrid columns=\"4\" source=\"post_type:post|by_id:2562,2534,2351,2347\"][/vc_column][/vc_row]","post_title":"San Francisco Museum of Modern Art","post_link":"https://www.heyusa.com/nl/san-francisco-museum-modern-art/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"SF MOMA\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/SF-MOMA-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea San Francisco","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1667979001:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"55","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_yoast_wpseo_metadesc%":"Het San Francisco Museum of Modern Art is de plek in San Francisco voor kunstliefhebbers. Tips voor je bezoek aan het San Francisco Museum of Modern Art.","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"San Francisco Museum of Modern Art","%_yoast_wpseo_title%":"San Francisco Museum of Modern Art%%page%% %%sep%% %%sitename%%","%_yoast_wpseo_linkdex%":"69","%inline_featured_image%":"0","%_thumbnail_id%":"3279","%_wpgmp_location_address%":"151 3rd St, San Francisco, CA 94103, Verenigde Staten","%_wpgmp_location_city%":"San Francisco","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"37.7857182","%_wpgmp_metabox_longitude%":"-122.4010508","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015438","taxonomy=category":"Musea San Francisco","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":2451,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Cable Car Museum","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Cable Car Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/11/Cable-Car-Museum-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Cable Car Museum</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1201 Mason St, San Francisco, CA 94108, Verenigde Staten","location":{"lat":"37.7946366","city":"San Francisco","state":"California","country":"Verenigde Staten","lng":"-122.4115074","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/cable-car-museum-san-francisco/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"25px\"][ultimate_heading main_heading=\"Cable Car Museum in San Francisco\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:30px;\" main_heading_line_height=\"desktop:35px;\"][/ultimate_heading][vc_column_text]<strong>In de wijk Nob Hill vind je het Cable Car Museum. De plek om alles te weten te komen over de kabeltram die nog steeds door San Francisco rijdt. Natuurlijk kun je in het museum oude exemplaren bekijken en bij verschillende tentoonstellingen hoor en lees je alle ins en outs over de Cable Car.</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Nob Hill | 1201 Mason Street\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek je tickets\" btn_link=\"url:http%3A%2F%2Fwww.cablecarmuseum.org%2F|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Sinds 1873 een begrip in San Francisco\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">De kabeltram in San Francisco is een stukje historie. Sinds 1873 rijdt de Cable Car door de straten van San Francisco om de steile heuvels te trotseren. En na al die jaren rijdt de kabeltram nog steeds door San Francisco. Een unieke ervaring om plaats te nemen in een Cable Car en over de steile heuvels van San Francisco te rijden.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Heuvel op, heuvel af\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"San Francisco's unieke vervoermiddel\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"7934\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Clay Street Hill Railroad Car #8\" heading_tag=\"h6\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Railroad Car #8 was een van de eerste Cable Cars die gebruikt werd in San Francisco. De kabeltram was onderdeel van de Clay Street Hill Railroad waarvan Andrew Hallidie de eigenaar was. Hij werd gezien als de 'vader' van de Cable Cars. Deze antieke kabeltram mag je niet missen tijdens je bezoek aan het museum.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"The Sutter Street Railway #46 grip car &amp; #54 trailer\" heading_tag=\"h6\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Naast de Clay Street Hill Railroad #8, staan er nog twee antieke Cable Cars in het museum: The Sutter Street Railway\u00a0 #46 grip car &amp; #54 trailer. Het zijn kabeltrams die in de periode rond 1870 gebruikt werden in San Francisco. Een stukje historie![/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Tentoonstelling Cable Cars\" heading_tag=\"h6\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Naast antieke Cable Cars is er ook veel informatie te vinden over de geschiedenis van de Cable Car in San Francisco. Hoe werkt de kabeltram exact, wat moet een bestuurder doen, hoe zagen de toegangskaartjes eruit en hoe werkt de machinekamer? Allemaal interessante informatie over de kabeltram waardoor je meer komt te weten over de Cable Car.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"400px\"][ultimate_heading main_heading=\"Sinds 1873\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"De kabels en trams werken na ruim 140 jaar nog steeds!\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"400px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"7973\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Lees meer over San Francisco:\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][thb_postgrid columns=\"4\" source=\"post_type:post|by_id:2528,2421,2567,2572\"][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"Cable Car Museum","post_link":"https://www.heyusa.com/nl/cable-car-museum-san-francisco/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Cable Car Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/11/Cable-Car-Museum-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea San Francisco","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1665468800:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"55","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_yoast_wpseo_metadesc%":"San Francisco en de Cable Car horen bij elkaar. In het Cable Car Museum vind je alles over de kabeltram die door San Francisco rijdt.","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_focuskw%":"Cable Car Museum San Francisco","%_yoast_wpseo_title%":"%%title%% San Francisco%%page%% %%sep%% %%sitename%%","%_yoast_wpseo_linkdex%":"71","%_thumbnail_id%":"3328","%inline_featured_image%":"0","%_wpgmp_location_address%":"1201 Mason St, San Francisco, CA 94108, Verenigde Staten","%_wpgmp_location_city%":"San Francisco","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"37.7946366","%_wpgmp_metabox_longitude%":"-122.4115074","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015441","taxonomy=category":"Musea San Francisco","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":2443,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Pier 39 in San Francisco","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pier 39\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/Pier-39-SF-1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Pier 39 in San Francisco</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"The Embarcadero, San Francisco, CA 94133, Verenigde Staten","location":{"lat":"37.808673","city":"San Francisco","state":"California","country":"Verenigde Staten","lng":"-122.409821","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/pier-39-san-francisco/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Pier 39 in San Francisco\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Pier 39 is om meerdere redenen een bezienswaardigheid in San Francisco. Er zijn vele activiteiten bij de pier in <a href=\"https://www.heyusa.com/nl/san-francisco/fishermans-wharf/\" target=\"_blank\" rel=\"noopener\">Fisherman's Wharf</a>. Maar ook de kolonie zeehonden die er vaak ligt trekt veel bekijks. Kortom, Pier 39 is een plek waar je redelijk wat tijd door kunt brengen. Wat mag je niet missen tijdens je bezoek aan Pier 39 in San Francisco!\r\n</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Gratis[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Tips voor een bezoek aan Pier 39\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Pier 39 bevindt zich in de wijk Fisherman's Wharf. Naast vele winkels, restaurants, een arcadehal, een informatiecentrum en vele straatmuzikanten zijn de zeeleeuwen de belangrijkste trekpleister. Vanaf Pier 39 heb je een uitzicht over Alcatraz en de Golden Gate Bridge.</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1640065446664{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Pier 39\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][vc_custom_heading text=\"Een gezellige drukte\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"3252\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Zeeleeuwen bij Pier 39\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Op de pontons bij de jachthaven ligt een kolonie Californische zeeleeuwen. Sinds 1989 bevinden ze zich in de baai. Daarvoor lagen ze buiten de baai van San Francisco. Het begon met ongeveer 10 zeeleeuwen, inmiddels is het aantal enorm toegenomen, soms zijn er wel 1500. Heel af en toe komt het voor dat er geen een kan spotten, maar meestal heb je geluk wel een paar rustende zeeleeuwen te spotten.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Wat te doen bij Pier 39?\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Naast de zeeleeuwen zijn er nog bezienswaardigheden die Pier 39 de moeite waard maken:\r\n<ul>\r\n \t<li><a href=\"https://www.aquariumofthebay.org/\" target=\"_blank\" rel=\"noopener noreferrer\">Aquarium of the Bay</a>; het aquarium die je kennis laat maken met het leven onder water in de baai van San Francisco.</li>\r\n \t<li><a href=\"https://museemecanique.com/\" target=\"_blank\" rel=\"noopener noreferrer\">Musee Mechanique</a>; in een grote hal vind je arcadespellen uit de jaren '10 en '20. Het museum is gratis, maar om te spelen moet je vaak iets betalen.</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Pier 39\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Rubik Mono One|font_call:Rubik+Mono+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_custom_heading text=\"Vlonders vol zeeuleeuwen\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"3251\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk in San Francisco:\" font_container=\"tag:div|font_size:50|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:2534,2421,2275,2351\"][/vc_column][/vc_row]","post_title":"Pier 39 in San Francisco","post_link":"https://www.heyusa.com/nl/pier-39-san-francisco/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pier 39\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/Pier-39-SF-1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden San Francisco","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1640065446664{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1665468661:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"50","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_yoast_wpseo_focuskw%":"Pier 39 San Francisco","%_yoast_wpseo_title%":"%%title%% San Francisco %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een van de bezienswaardigheden in San Francisco die je niet mag missen is Pier 39 in Fisherman's Wharf. Tips voor je bezoek aan Pier 39","%_yoast_wpseo_linkdex%":"75","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_thumbnail_id%":"3250","%inline_featured_image%":"0","%_wpgmp_location_address%":"The Embarcadero, San Francisco, CA 94133, Verenigde Staten","%_wpgmp_location_city%":"San Francisco","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"37.808673","%_wpgmp_metabox_longitude%":"-122.409821","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015444","taxonomy=category":"Bezienswaardigheden San Francisco","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":2431,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Lombard Street San Francisco","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lombard Street\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/Lombard-Street-SF-3-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Lombard Street San Francisco</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Lombard St, San Francisco, CA, Verenigde Staten","location":{"lat":"37.8009995","city":"San Francisco","state":"California","country":"Verenigde Staten","lng":"-122.4267278","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/lombard-street-san-francisco/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Lombard Street San Francisco\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">De beroemdste straat van San Francisco is Lombard Street. Hoewel het een hele lange straat is die door San Francisco loopt, gaat het eigenlijk om een klein stukje. Dit stukje is namelijk de meest bochtige straat ter wereld. Slechts een huizenblok lang, maar toch vind je hier 8 scherpe bochten.\r\n</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Gratis[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Tips voor een bezoek aan Lombard Street\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Het bochtige stukje van Lombard Street vind je tussen Hyde Street en Leavonworth Street. Dagelijks komen hier veel toeristen op af en daardoor kan het soms druk zijn. Durf jij het aan om met de auto naar beneden te rijden? Houd dan rekening met vertraging en files. Een betere manier om Lombard Street te bekijken is door de auto in de buurt te parkeren en lopend die kant op te gaan.</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1640065446664{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Autorijden op Lombard Street\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][vc_custom_heading text=\"Durf jij het aan?\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"3254\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Hoe kom je bij Lombard Street\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Heb je geen auto of wil je die laten staan? Dan is de <a href=\"https://www.heyusa.com/nl/cable-cars-san-francisco/\" target=\"_blank\" rel=\"noopener\">Cable Car</a> een goede optie. Vanaf <a href=\"https://www.heyusa.com/nl/san-francisco/fishermans-wharf/\" target=\"_blank\" rel=\"noopener\">Fisherman's Wharf</a> en Union Square kun je de kabeltram nemen. Je wordt aan de bovenkant van Lombard Street afgezet. Neem de Powel - Hide lijn om Lombard Street te bezoeken. Uitstappen doe je bij<a href=\"https://www.sfmta.com/sites/default/files/pm-ph_mason-hyde_pdf.pdf\" target=\"_blank\" rel=\"noopener\"> Hyde Street &amp; Chestnut Street</a>\r\n</span>\r\n\r\nMet de auto kun je het beste in de buurt parkeren en dan het laatste stukje lopend afleggen. Het is vaak druk bij Lombard Street, dus er langs rijden kost veel tijd.\r\n\r\nOok met de fiets kun je San Francisco verkennen. Fietsend Lombard Street afrijden is niet te doen, maar lopend met de fiets aan je hand is een beter idee.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Facts over Lombard Street\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<ul>\r\n \t<li>Dit stukje Lombard Street heeft een stijgingspercentage van 27%.</li>\r\n \t<li>Soms wordt de straat afgesloten vanwege de drukte. Alleen bewoners mogen dan nog Lombard Street op.</li>\r\n \t<li>Stiekem is Vermont Street, iets verderop, nog bochtiger dan Lombard Street. Deze weg heeft maar 1 haarspeldbocht, maar is lastig om te rijden.</li>\r\n \t<li>Sinds 1939 is Lombard Street een eenrichtingstraat.</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Lombard Street vanuit de lucht\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][vc_custom_heading text=\"Zigzaggend door San Francisco\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"3255\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk in San Francisco:\" font_container=\"tag:div|font_size:50|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:2567,2351,2347,2562\"][/vc_column][/vc_row]","post_title":"Lombard Street San Francisco","post_link":"https://www.heyusa.com/nl/lombard-street-san-francisco/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lombard Street\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/Lombard-Street-SF-3-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden San Francisco","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1640065446664{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1665468613:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"50","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_yoast_wpseo_focuskw%":"Lombard Street San Francisco","%_yoast_wpseo_metadesc%":"De beroemdste straat van San Francisco is Lombard Street. De haarspeldbocht is een uitdaging voor auto's, voetgangers en fietsers.","%_yoast_wpseo_linkdex%":"77","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_thumbnail_id%":"3256","%inline_featured_image%":"0","%_wpgmp_location_address%":"Lombard St, San Francisco, CA, Verenigde Staten","%_wpgmp_location_city%":"San Francisco","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"37.8009995","%_wpgmp_metabox_longitude%":"-122.4267278","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015447","taxonomy=category":"Bezienswaardigheden San Francisco","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":2421,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Cable Cars San Francisco","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Cable Car San Francisco\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/Cable-Car-SF-1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Cable Cars San Francisco</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1598 US-101, San Francisco, CA 94109, Verenigde Staten","location":{"lat":"37.7904133","city":"San Francisco","state":"California","country":"Verenigde Staten","lng":"-122.4220916","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/cable-cars-san-francisco/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Cable Cars San Francisco\" font_container=\"tag:div|font_size:35|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Naast de <a href=\"https://www.heyusa.com/nl/san-francisco/golden-gate-bridge/\" target=\"_blank\" rel=\"noopener\">Golden Gate Bridge</a> en <a href=\"https://www.heyusa.com/nl/san-francisco/alcatraz-bezoeken/\" target=\"_blank\" rel=\"noopener\">Alcatraz</a> staan ook de Cable Cars symbool voor San Francisco. Sinds eind 19e eeuw rijden deze al door de straten van San Francisco. In eerste instantie als openbaar vervoer, nu zijn ze vooral een publiekstrekker voor de stad.\r\n</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]$8[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"De routes van de Cable Car\" font_container=\"tag:div|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">In San Francisco rijden de cable cars op 3 verschillende routes; de Powell / Hyde Straat route, de Powell / Mason Street route en de California Street route. De Powell - Hyde route is de meest toeristische en komt langs <a href=\"https://www.heyusa.com/nl/san-francisco/lombard-street/\" target=\"_blank\" rel=\"noopener\">Lombard Street</a> en start bij <a href=\"http://www.heyusa.com/nl/san-francisco/fishermans-wharf/\" target=\"_blank\" rel=\"noopener noreferrer\">Fisherman's Wharf</a>.</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Op en neer over de heuvels\" font_container=\"tag:div|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Een leuke en goedkope manier om San Francisco te ontdekken\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"3247\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Tips voor een ritje met de Cable Car\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">De Powell - Hyde en de Powell -Mason route zijn de meest toeristische routes. De California lijn is daarentegen een stuk rustiger, maar goed deze rijdt ook niet langs toeristische bezienswaardigheden. Wil je toch mee rijden op de eerste twee routes? Loop dan naar de 1e of 2e halte op de route. De Cable Car vertrekt namelijk nooit helemaal vol zodat mensen onderweg ook kunnen instappen. Een kaartje kun je kopen via de <a href=\"https://www.sfmta.com/getting-around/muni/fares/munimobile\" target=\"_blank\" rel=\"noopener\">MuniMobile App</a>.\r\n</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Stukje geschiedenis Cable Cars\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Op de gladde heuvels gebeurden regelmatig ongelukken in de negentiende eeuw. De paardentrams die gebruikt werden waren niet ideaal. Andrew Smith Hallidie besloot dat het genoeg was en nam het initiatief. In 1873 reden de eerste kabeltrams over Nob Hill. Sindsdien is er weinig veranderd in het straatbeeld van San Francisco. Ook de besturing gaat na al die jaren nog handmatig.\r\nWil je nog meer te weten komen over de Cable Cars? Bezoek dan het <a href=\"https://www.heyusa.com/nl/san-francisco/cable-car-museum/\" target=\"_blank\" rel=\"noopener\">Cable Car Museum</a>.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Enjoy the view!\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][vc_custom_heading text=\"Uitzicht over de steile straten van San Francisco\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"3246\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk in San Francisco:\" font_container=\"tag:div|font_size:45|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:2431,2421,2351,2443\"][/vc_column][/vc_row]","post_title":"Cable Cars San Francisco","post_link":"https://www.heyusa.com/nl/cable-cars-san-francisco/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Cable Car San Francisco\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/Cable-Car-SF-1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden San Francisco","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1665468545:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"50","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_yoast_wpseo_focuskw%":"Cable Cars San Francisco","%_yoast_wpseo_metadesc%":"Een van de highlights van San Francisco zijn de Cable Cars in San Francisco. Stap in een van de Cable Cars in San Francisco.","%_yoast_wpseo_linkdex%":"78","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_thumbnail_id%":"3248","%inline_featured_image%":"0","%_wpgmp_location_address%":"1598 US-101, San Francisco, CA 94109, Verenigde Staten","%_wpgmp_location_city%":"San Francisco","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"37.7904133","%_wpgmp_metabox_longitude%":"-122.4220916","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015449","taxonomy=category":"Bezienswaardigheden San Francisco","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":2416,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Stratosphere Tower Observation Deck Las Vegas","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Stratosphere Tower Observation Deck\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/Stratosphere-Tower1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Stratosphere Tower Observation Deck Las Vegas</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"2000 Las Vegas Blvd S, Las Vegas, NV 89104, Verenigde Staten","location":{"lat":"36.1475119","city":"Las Vegas","state":"Nevada","country":"Verenigde Staten","lng":"-115.1565537","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/las-vegas/stratosphere-tower-observation-deck/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Stratosphere Tower Observation Deck Las Vegas\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_column_text]<span style=\"font-weight: 400;\">Geniet van het uitzicht van het <a href=\"https://www.getyourguide.com/las-vegas-l58/las-vegas-strat-tower-skypod-observation-deck-ticket-t402331/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=heyusa_website\" target=\"_blank\" rel=\"noopener\">observatiedek van de Stratosphere Tower Observation Deck</a>. Op meer dan 350 meter hoogte kun je Las Vegas in panorama bekijken. De observatietoren is het op een na hoogste observatiedek in het westelijke halfrond. Met minder goed weer kun je Las Vegas vanaf binnen kijken, met mooi weer kun je de stad zien vanaf het terras.\u00a0\u00a0</span>\r\n\r\nEn wil je meer avontuur? Stap dan in \u00e9\u00e9n van de <a href=\"https://www.heyusa.com/nl/achtbanen-attracties-las-vegas/\" target=\"_blank\" rel=\"noopener\">attracties</a> die zich op het Stratosphere bevinden![/vc_column_text][vc_custom_heading text=\"Handige informatie voor het Stratosphere Tower Observation Deck Las Vegas\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<b>Duur:</b><span style=\"font-weight: 400;\"> 4 uur</span><span style=\"font-weight: 400;\">\r\n</span><b>Prijs</b><span style=\"font-weight: 400;\">: Vanaf 17 euro</span><span style=\"font-weight: 400;\">\r\n</span><b>Vertreklocatie</b><span style=\"font-weight: 400;\">: Stratosphere Tower, 2000 Las Vegas Blvd S Stratosphere Casino Hotel &amp; Tower</span><span style=\"font-weight: 400;\">\r\n</span><b>Openingstijden:</b> Van maandag tot en met zondag van 10.00 - 23.30 uur[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Flas-vegas-l58%2Flas-vegas-strat-tower-skypod-observation-deck-ticket-t402331%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dstratosphere|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"20px\"][/vc_column][vc_column width=\"1/3\"][thb_image retina=\"retina_size\" box_shadow=\"medium-shadow\" thb_border_radius=\"10px\" image=\"4442\"][/thb_image][vc_empty_space height=\"20px\"][vc_column_text][/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Meer foto's van de Stratosphere Tower\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][thb_image_slider images=\"5899,4443,4442,3751,3748\"][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Las Vegas\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:3660,2400,2396,2394\"][/vc_column][/vc_row]","post_title":"Stratosphere Tower Observation Deck Las Vegas","post_link":"https://www.heyusa.com/nl/las-vegas/stratosphere-tower-observation-deck/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Stratosphere Tower Observation Deck\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/Stratosphere-Tower1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Las Vegas","post_tags":"","%_edit_last%":"1","%_edit_lock%":"1711526704:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"54","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style3","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":{"2":{"title":"","post_source_url":""}},"%_yoast_wpseo_focuskw%":"Stratosphere Tower Observation Deck","%_yoast_wpseo_metadesc%":"Op zoek naar een toffe ervaring in Las Vegas? Boek dan een ticket voor het Stratosphere Tower Observation Deck Las Vegas.","%_yoast_wpseo_linkdex%":"68","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Stratosphere Tower Observation Deck Las Vegas\"]","%_wpgmp_location_address%":"2000 Las Vegas Blvd S, Las Vegas, NV 89104, Verenigde Staten","%_wpgmp_location_city%":"Las Vegas","%_wpgmp_location_state%":"Nevada","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"36.1475119","%_wpgmp_metabox_longitude%":"-115.1565537","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"3748","%inline_featured_image%":"0","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1677015453","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","taxonomy=category":"Bezienswaardigheden Las Vegas","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":2398,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Fly LINQ Zipline Las Vegas","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"fly linq\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/fly-linq-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Fly LINQ Zipline Las Vegas</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"3545 S Las Vegas Blvd, Las Vegas, NV 89109, Verenigde Staten","location":{"lat":"36.1177747","city":"Las Vegas","state":"Nevada","country":"Verenigde Staten","lng":"-115.1725759","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/las-vegas/fly-linq-zipline/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Fly LINQ Zipline in Las Vegas\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"20px\"][vc_column_text]<span style=\"font-weight: 400;\">Houd je van spanning en ben je niet bang voor hoogtes? Zin in een uniek uitzicht over de straten van Las Vegas? Laat je vastmaken in de zipline die op een hoogte van 12 verdiepingen boven de LINQ Promenade zoeft. Geniet van het uitzicht wanneer via je een zipline door Las Vegas gaat. Start op de Las Vegas Boulevard en eindig bij de High Roller. Je kunt zittend of als een superheld via de zipline de rit maken. De <a href=\"https://www.getyourguide.com/las-vegas-l58/fast-track-ticket-fly-linq-zipline-t276162/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=heyusa_website\" target=\"_blank\" rel=\"noopener\">Fly LINQ Zipline</a> is de activiteit voor adrenaline junkies in <a href=\"https://www.heyusa.com/nl/las-vegas/\">Las Vegas!</a></span>[/vc_column_text][vc_custom_heading text=\"Handige informatie Fly LINQ Zipline in Las Vegas\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<b>Duur:</b><span style=\"font-weight: 400;\">\u00a0 30 minuten</span><span style=\"font-weight: 400;\">\r\n</span><b>Prijs</b><span style=\"font-weight: 400;\">: Vanaf 35 euro</span><span style=\"font-weight: 400;\">\r\n</span><b>Vertrek</b><span style=\"font-weight: 400;\">: FLY LINQ Zipline Las Vegas, 3545 S Las Vegas Blvd</span><span style=\"font-weight: 400;\">\r\n</span><b>Openingstijden:</b> donderdag t/m maandag 16.00 - middernacht[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Flas-vegas-l58%2Ffast-track-ticket-fly-linq-zipline-t276162%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dflylinq|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"20px\"][/vc_column][vc_column width=\"1/3\"][thb_image retina=\"retina_size\" box_shadow=\"medium-shadow\" thb_border_radius=\"10px\" image=\"3754\"][/thb_image][vc_empty_space height=\"20px\"][vc_column_text][/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Las Vegas\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"by_id:4389,4474,4434,4337\"][/vc_column][/vc_row]","post_title":"Fly LINQ Zipline Las Vegas","post_link":"https://www.heyusa.com/nl/las-vegas/fly-linq-zipline/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"fly linq\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/fly-linq-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Las Vegas","post_tags":"","%_edit_last%":"1","%_edit_lock%":"1667477863:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"54","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style3","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":{"2":{"title":"","post_source_url":""}},"%_yoast_wpseo_focuskw%":"Fly LINQ Zipline","%_yoast_wpseo_metadesc%":"Ziplinend Las Vegas verkennen? Dat kan! Fly LINQ Zipline Las Vegas maakt het mogelijk om via een zipline door Las Vegas te vliegen.","%_yoast_wpseo_linkdex%":"67","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Zipline Las Vegas\"]","%_wpgmp_location_address%":"3545 S Las Vegas Blvd, Las Vegas, NV 89109, Verenigde Staten","%_wpgmp_location_city%":"Las Vegas","%_wpgmp_location_state%":"Nevada","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"36.1177747","%_wpgmp_metabox_longitude%":"-115.1725759","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"11418","%inline_featured_image%":"0","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1677015457","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Bezienswaardigheden Las Vegas","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":2388,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Golden Gate Bridge","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Golden Gate Bridge\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/Golden-Gate-Bridge-SF-2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Golden Gate Bridge</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Golden Gate Bridge, San Francisco, CA, Verenigde Staten","location":{"lat":"37.8199286","city":"San Francisco","state":"California","country":"Verenigde Staten","lng":"-122.4782551","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/golden-gate-bridge-san-francisco/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Golden Gate Bridge San Francisco\" font_container=\"tag:div|font_size:35|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">De Golden Gate Bridge staat synoniem voor San Francisco. De rode hangbrug werd in vele films gebruikt als decor en is daardoor voor velen een bekend plaatje. In ongeveer vier jaar werd de brug gebouwd en hij werd feestelijk geopend op 27 mei 1937. Het is een van de zeven moderne wereldwonderen.\r\n</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Gratis[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Tips voor fietsen op de Golden Gate Bridge\" font_container=\"tag:div|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">Huur een fiets bij een van de vele fietsverhuurders in de buurt van Fisherman's Wharf en fiets over de Golden Gate Bridge, misschien wel een van de tofste activiteiten om te doen in San Francisco. Eenmaal aan de overkant kun je terug op de fiets, of de ferry pakken naar <a href=\"https://www.heyusa.com/nl/san-francisco/fishermans-wharf/\" target=\"_blank\" rel=\"noopener\">Fisherman's Wharf</a>.</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Must do in San Francisco!\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Fietsen over de Golden Gate Bridge\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"3260\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Bouw van de Golden Gate Bridge\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Voor de bouw van de Golden Gate Bridge was de enige manier om de baai over te steken per ferry. Hoewel het maar 20 minuten duurde, wilde men toch kijken naar een brug tussen beiden delen van de stad. Vaak werd gedacht dat de sterke stroming en de diepte van de baai voor problemen zouden zorgen, maar niets is minder waar. Op 5 januari 1933 werd begonnen met bouwen en in april 1937 was de Golden Gate Bridge een feit.\r\n</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Weetjes over de Golden Gate Bridge\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<ul>\r\n \t<li><span style=\"font-weight: 400;\">De kleur van de brug, international orange, werd gekozen omdat hij ook bij mist te zien zou zijn.</span></li>\r\n \t<li>Er zijn tijdens de bouw 11 bouwvakkers omgekomen ondanks het net onder de brug hing.</li>\r\n \t<li>In de eerste 70 jaar hebben ruim 1300 mensen zelfmoord gepleegd van de Golden Gate Bridge.</li>\r\n \t<li>In <a href=\"https://www.imdb.com/title/tt2126355/\" target=\"_blank\" rel=\"noopener\">films</a> is de brug vaak een slachtoffer, hij stort dikwijls in.</li>\r\n</ul>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Typisch San Francisco\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"De Golden Gate Bridge in de mist\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"3258\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk in San Francisco:\" font_container=\"tag:div|font_size:50|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:2431,2195,2275,2421\"][/vc_column][/vc_row]","post_title":"Golden Gate Bridge","post_link":"https://www.heyusa.com/nl/golden-gate-bridge-san-francisco/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Golden Gate Bridge\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/Golden-Gate-Bridge-SF-2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden San Francisco","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1669884322:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"50","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_yoast_wpseo_focuskw%":"Golden Gate Bridge San Francisco","%_yoast_wpseo_title%":"%%title%% San Francisco %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een van de highlights van San Francisco is de Golden Gate Bridge. Fiets over de Golden Gate Bridge en bekijk een van de zeven moderne wereldwonderen.","%_yoast_wpseo_linkdex%":"75","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Golden Gate Bridge \"]","%_thumbnail_id%":"3259","%inline_featured_image%":"0","%_wpgmp_location_address%":"Golden Gate Bridge, San Francisco, CA, Verenigde Staten","%_wpgmp_location_city%":"San Francisco","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"37.8199286","%_wpgmp_metabox_longitude%":"-122.4782551","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015461","taxonomy=category":"Bezienswaardigheden San Francisco","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":2351,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Coit Tower San Francisco","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coit Tower\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/Coit-Tower-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Coit Tower San Francisco</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"Uitkijkplatform op Coit Tower","address":"1 Telegraph Hill Blvd, San Francisco, CA 94133, Verenigde Staten","location":{"lat":"37.8023949","city":"San Francisco","state":"California","country":"Verenigde Staten","lng":"-122.4058222","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/coit-tower-san-francisco/","zoom":12,"extra_fields":{"post_excerpt":"Uitkijkplatform op Coit Tower","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Coit Tower in San Francisco\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Op Telegraph Hill vind je de uitkijktoren Coit Tower. Een 64 meter hoge toren die al sinds 1934 op de heuvels van San Francisco staat. Op een heldere dag kun je de gehele baai rondom San Francisco bekijken. Bestijg op een mooie dag de trappen van de Coit Tower en je wordt niet teleurgesteld over het uitzicht.[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend, m.u.v Thanksgiving, Kerst en 1 januari[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf $9[/ultimate_icon_list_item][/ultimate_icon_list][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Freservations.arestravel.com%2Fattraction%2Flist%2F8820%2Fm71%3Fvariation%3Dorig\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\" btn_line_height=\"desktop:1px;\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Over Coit Tower\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Met een beetje geluk spot je de Coit Tower vanuit <a href=\"https://www.heyusa.com/nl/los-angeles/dowtown-los-angeles/\" target=\"_blank\" rel=\"noopener\">Downtown San Francisco</a>. Via de steile Filbert Steps kun je de beklimming maken naar Telegraph Hill. Je wandelt tussen schattige huisjes en tuinen van de bewoners.</p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1640065446664{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Coit Tower\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][vc_custom_heading text=\"Uitzicht over San Francisco\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"3316\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row][vc_empty_space][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Gift van Lillie Hitchcock\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De Coit Tower is een gift van de rijke Lillie Hitchcock. Zij vereerde de brandweermannen van San Francisco. Na haar dood liet ze de stad 100.00 dollar na ter verfraaiing van de stad. Hiervan werd de Coit Tower gebouwd ter ere van de vrijwillige brandweer. Maar ook kreeg San Francisco er op deze manier een bezienswaardigheid er bij.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"De vorm van Coit Tower\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Deels ter ere van de vrijwillige brandweer werd de Coit Tower gebouwd in 1934, een uitkijktoren vanaf waar je een prachtig uitzicht hebt over de stad. Volksverhalen geven aan dat de vorm van de toren overeenkomt met het uiteinde van een brandslang. Niet exact de bedoeling van de architecten, maar stiekem klopt dit wel.[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Coit Tower\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][vc_custom_heading text=\"Durf jij omhoog?\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"3317\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tickets voor Coit Tower\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Tickets voor de Coit Tower kun je <a href=\"https://reservations.arestravel.com/attraction/list/8820/m71?variation=orig\" target=\"_blank\" rel=\"noopener\">online</a> aanschaffen. Je kunt hierdoor de rij overslaan bij de toren zelf.\r\n\r\nParkeren bij de toren is lastig, er is een kleine parkeerplaats. Vanaf Fisherman's Wharf kun je beter de bus pakken: Muni's #39 Coit Bus.\r\n\r\nWandelen kan ook vanaf de oostelijk kant van de heuvel via de Filbert Street stairs.[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Freservations.arestravel.com%2Fattraction%2Flist%2F8820%2Fm71%3Fvariation%3Dorig\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\" btn_line_height=\"desktop:1px;\"][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie Coit Tower\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>1 Telegraph Hill Blvd</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Dagelijks afhankelijk van het seizoen;\r\n- April - October: 10.00-1800 uur\r\n- November - Maart: 10.00-17.00 uur</strong>[/ultimate_icon_list_item][/ultimate_icon_list][vc_custom_heading text=\"Wat is het beste moment om Coit Tower te bezoeken?\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Vaak is het weekend het drukste moment om te bezoeken. Kies voor een tijdstip vroeg op de dag.[/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Enjoy the view!\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_custom_heading text=\"Coit Tower in de skyline van San Francisco\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"3318\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk in San Francisco:\" font_container=\"tag:div|font_size:50|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:2416,2275,2528,2534\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row][vc_empty_space][/vc_column][vc_column][/vc_column][/vc_row]","post_title":"Coit Tower San Francisco","post_link":"https://www.heyusa.com/nl/coit-tower-san-francisco/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coit Tower\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/Coit-Tower-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden San Francisco","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1640065446664{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1665468284:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"50","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_oembed_e1e9f839942dd1e1028c231627ec1c1b%":"<blockquote class=\"wp-embedded-content\" data-secret=\"MxTlgp7UD8\"><a href=\"https://www.gibsonssteakhouse.com/locations/gibsons-chicago/\">Gibsons Downtown Chicago Restaurant</a></blockquote><iframe class=\"wp-embedded-content\" sandbox=\"allow-scripts\" security=\"restricted\" style=\"position: absolute; clip: rect(1px, 1px, 1px, 1px);\" title=\"&#8220;Gibsons Downtown Chicago Restaurant&#8221; &#8212; Gibsons Bar &amp; Steakhouse\" src=\"https://www.gibsonssteakhouse.com/locations/gibsons-chicago/embed/#?secret=MxTlgp7UD8\" data-secret=\"MxTlgp7UD8\" width=\"600\" height=\"338\" frameborder=\"0\" marginwidth=\"0\" marginheight=\"0\" scrolling=\"no\"></iframe>","%_oembed_time_e1e9f839942dd1e1028c231627ec1c1b%":"1602580958","%_yoast_wpseo_focuskw%":"Coit Tower in San Francisco","%_yoast_wpseo_title%":"Tips voor je bezoek aan de Coit Tower in San Francisco %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Wat te doen in San Francisco? Bezoek de Coit Tower op Telegraph Hill. Tips voor je bezoek aan de Coit Tower in San Francisco.","%_yoast_wpseo_linkdex%":"76","%_thumbnail_id%":"3282","%inline_featured_image%":"0","%_wpgmp_location_address%":"1 Telegraph Hill Blvd, San Francisco, CA 94133, Verenigde Staten","%_wpgmp_location_city%":"San Francisco","%_wpgmp_location_state%":"California","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"37.8023949","%_wpgmp_metabox_longitude%":"-122.4058222","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015463","taxonomy=category":"Bezienswaardigheden San Francisco","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":2347,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Alcatraz","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Alcatraz San Francisco\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/Alcatraz-1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Alcatraz</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"Alcatraz bezoeken in San Francisco","address":"Alcatraz, San Francisco, Californi\u00eb, Verenigde Staten","location":{"lat":"37.8266636","city":"San Francisco","state":"Californi\u00eb","country":"Verenigde Staten","lng":"-122.4230122","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/alcatraz-san-francisco/","zoom":12,"extra_fields":{"post_excerpt":"Alcatraz bezoeken in San Francisco","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Tips voor je bezoek aan Alcatraz\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Een van de bekendste gevangenissen ter wereld is Alcatraz op Alcatraz Island in San Francisco. Hoewel het nog geen 30 jaar dienst deed als een gevangenis, heeft het roem gekregen in die periode. Gevangene worden op een eiland voor de kust van San Francisco moest ervoor zorgen dat ontsnappen onmogelijk was. Tips voor je bezoek aan Alcatraz in San Francisco en alles wat je moet weten over de gevangenis Alcatraz![/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend, m.u.v Thanksgiving, Kerst en 1 januari[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf $39[/ultimate_icon_list_item][/ultimate_icon_list][ult_buttons btn_title=\"Bestel je tickets voor een bezoek aan Alcatraz in combinatie met een tour door Fisherman's Wharf\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fsan-francisco-l61%2Fsan-francisco-alcatraz-at-night-fisherman-s-wharf-t389056%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dalcatrazcombiticket|title:Bestel%20je%20tickets\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Alcatraz - de bekendste gevangenis van Amerika\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">Menigeen kent Alcatraz van de film\u00a0<em>Escape From Alcatraz</em>, de film waarin drie gevangenen proberen te ontsnappen. Het idee van een gevangenis op een eiland, was natuurlijk dat er niemand kon ontsnappen en voorzover ze weten is het niemand gelukt te ontsnappen. Gevangenen als Al Capone werden daarom ondergebracht in Alcatraz.</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1640065446664{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Gevangeniseiland Alcatraz\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][vc_custom_heading text=\"Voor de kust van San Francisco\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"3269\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row][vc_empty_space][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Ontsnappingen op Alcatraz\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Door de ligging op een eiland en de ijskoude stromingen in de baai van San Francisco was het idee dat ontsnappen onmogelijk was vanaf Alcatraz. Toch weerhield het de gedetineerden er niet van pogingen te doen. In al die jaren hebben 36 gevangen geprobeerd te ontsnappen, 23 werden gepakt, 6 doodgeschoten op de vlucht, twee verdronken en van 5 gevangenen hebben ze geen idee. Het blijft nog steeds een mysterie wat er met hun gebeurd is.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Wat kun je doen op Alcatraz?\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Op Alcatraz kun je door middel van een audiotour kennismaken met het eiland en zijn verleden. Gedurende 45 minuten word je door verhalen van oud medewerkers en ex gevangenen op de hoogte gebracht van het reilen en zeilen in de gevangenis. Hoogtepunt tijdens de tour zijn de cellen waar de gevangenen verbleven. Je mag ook nog een kijkje nemen op de luchtplaats, de keuken en de eetzaal. Buiten zie je de oude wachttoren en vuurtoren.[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1640065446664{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Ontdek Alcatraz\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][vc_custom_heading text=\"De cellen van de gevangenen\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"3267\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tickets voor Alcatraz\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Alcatraz tickets dien je ruim voor je bezoek aan te schaffen <a href=\"https://www.alcatrazcruises.com/nl/\">online</a>. Helaas ligt je bezoek daardoor redelijk vast, maar wanneer je last minute het eiland wil bezoeken, maak je weinig kans.\r\n\r\nJe kunt tickets boeken voor de dagtocht, de nachtelijke rondleiding en de achter scenes tour.\r\n\r\nDe boten vertrekken bij Pier 33, net iets verder dan Fisherman's Wharf. Combineer dan ook een bezoek aan Alcatraz met <a href=\"https://www.heyusa.com/nl/san-francisco/fishermans-wharf/\">Fisherman's Wharf</a> en de <a href=\"https://www.heyusa.com/nl/pier-39-san-francisco/\">zeeleeuwen op Pier 39</a>.[/vc_column_text][ult_buttons btn_title=\"Bestel hier je losse tickets voor Alcatraz\" btn_link=\"url:https%3A%2F%2Fwww.alcatrazcruises.com%2Fnl%2F|title:Bestel%20je%20tickets\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"1/2\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23c90c0f\" google_fonts=\"font_family:Rubik%20Mono%20One%3A400|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Ga mee met de zonsondergang tour en beleef Alcatraz zowel in het licht als donker!\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Arvo%3Aregular%2Citalic%2C700%2C700italic|font_style:700%20bold%20italic%3A700%3Aitalic\"][/vc_column_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie voor een bezoek aan Alcatraz\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>Pier 33 Alcatraz Landing</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Dagelijks afhankelijk van het seizoen; eerste afvaart vaak 8.45 uur - laatste rond 16.00-17.00 uur.</strong>[/ultimate_icon_list_item][/ultimate_icon_list][vc_custom_heading text=\"Wat is het beste moment om Alcatraz te bezoeken?\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Wanneer je het eiland in alle rust wilt bekijken, is het een aanrader om zo vroeg mogelijk de ferry te boeken. Ook wordt vaak de tour rond zonsondergang aangeraden, niet omdat het rustig is, maar vanwege de ervaring.[/vc_column_text][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"5/6\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23c90c0f\" google_fonts=\"font_family:Rubik%20Mono%20One%3A400|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Neem ongeveer twee uur de tijd voor je bezoek aan Alcatraz!\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Arvo%3Aregular%2Citalic%2C700%2C700italic|font_style:700%20bold%20italic%3A700%3Aitalic\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row][vc_empty_space height=\"250px\"][ultimate_heading main_heading=\"Boek een combiticket - Bezoek Alcatraz en fietsen over de Golden Gate Bridge\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][vc_custom_heading text=\"Twee toffe activiteiten in \u00e9\u00e9n!\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Falcatraz-l535%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26utm_source%3Dnwyrk_media%26placement%3D%2522other%2522%26cmp%3Dalcatraz|title:Bestel%20je%20tickets\" btn_align=\"ubtn-center\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"250px\"][parallax_row opacity=\"80\" image=\"3310\"][/vc_column][vc_column][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk in San Francisco:\" font_container=\"tag:div|font_size:50|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:2351,2421,2212,2431\"][/vc_column][/vc_row]","post_title":"Alcatraz","post_link":"https://www.heyusa.com/nl/alcatraz-san-francisco/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Alcatraz San Francisco\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/Alcatraz-1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden San Francisco","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1640065446664{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1640065446664{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}","%_edit_last%":"1","%_edit_lock%":"1667476918:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"50","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Tips voor je bezoek aan Alcatraz in San Francisco\"]","%_oembed_e1e9f839942dd1e1028c231627ec1c1b%":"<blockquote class=\"wp-embedded-content\" data-secret=\"MxTlgp7UD8\"><a href=\"https://www.gibsonssteakhouse.com/locations/gibsons-chicago/\">Gibsons Downtown Chicago Restaurant</a></blockquote><iframe class=\"wp-embedded-content\" sandbox=\"allow-scripts\" security=\"restricted\" style=\"position: absolute; clip: rect(1px, 1px, 1px, 1px);\" title=\"&#8220;Gibsons Downtown Chicago Restaurant&#8221; &#8212; Gibsons Bar &amp; Steakhouse\" src=\"https://www.gibsonssteakhouse.com/locations/gibsons-chicago/embed/#?secret=MxTlgp7UD8\" data-secret=\"MxTlgp7UD8\" width=\"600\" height=\"338\" frameborder=\"0\" marginwidth=\"0\" marginheight=\"0\" scrolling=\"no\"></iframe>","%_oembed_time_e1e9f839942dd1e1028c231627ec1c1b%":"1602580958","%_yoast_wpseo_focuskw%":"Alcatraz","%_yoast_wpseo_title%":"Tips voor je bezoek aan Alcatraz in San Francisco %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Tijdens je bezoek aan San Francisco de beroemde gevangenis Alcatraz bezoeken? Tips voor je bezoek aan Alcatraz Island in San Francisco.","%_yoast_wpseo_linkdex%":"81","%_thumbnail_id%":"3266","%inline_featured_image%":"0","%_wpgmp_location_address%":"Alcatraz, San Francisco, Californi\u00eb, Verenigde Staten","%_wpgmp_location_city%":"San Francisco","%_wpgmp_location_state%":"Californi\u00eb","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"37.8266636","%_wpgmp_metabox_longitude%":"-122.4230122","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%thb-reactions-votes%":"1","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015467","taxonomy=category":"Bezienswaardigheden San Francisco","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":2275,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Hop on Hop off Washington DC","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hop on Hop off Washington\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/Hop-on-Washington3-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Hop on Hop off Washington DC</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"50 Massachusetts Ave NE, Washington, DC 20002, Verenigde Staten","location":{"lat":"38.8978594","city":"Washington","state":"District of Columbia","country":"Verenigde Staten","lng":"-77.0062742","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/washington-dc/hop-on-hop-off/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"35px\"][ultimate_heading main_heading=\"Ontdek Washington met de Hop on Hop off\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]<span style=\"font-weight: 400;\">Een makkelijke en fijne manier om een stad te verkennen is per Hop on Hop off in Washington. Je stapt in waar je wil en wordt rondgereden door de stad. Wil je een museum of bezienswaardigheid bekijken? Dan stap je uit en pak je de route na het bezoek weer op.</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]Hele jaar door[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf \u20ac49[/ultimate_icon_list_item][/ultimate_icon_list][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fwashington-dc-l62%2Fwashington-dc-1-2-day-hop-on-hop-off-city-sights-bus-tour-t61881%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dhoponhopofwashingtoneerstebutton|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#000000\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1664485897627{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ontdek Washington per bus\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">De stad verkennen per bus en uitstappen bij bezienswaardigheden, klinkt ideaal toch? Alle topattracties van Washington worden aangedaan tijdens deze tour. Volg een van de twee verschillende routes door de stad en leer Washington kennen op een ontspannen manier.</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1664485277236{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Ontdek Washington vanuit je stoel\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"En hop of bij de leukste attracties!\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fwashington-dc-l62%2Fwashington-dc-1-2-day-hop-on-hop-off-city-sights-bus-tour-t61881%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dhoponhopofwashingtonfoto|title:Bestel%20je%20tickets|target:_blank\" btn_align=\"ubtn-center\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#000000\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"90\" enable_mobile=\"parallax-enable-mobile\" image=\"7105\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Tickets voor de Hop on Hop off in Washington\" heading_tag=\"h3\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]Tickets voor de Hop on Hop off kun je het beste al online kopen. Je hebt twee verschillende routes in Washington: The Patriot Loop en de Blue Loop. In de eerste route kun je meer dan 23 bezienswaardigheden bezoeken, in de tweede 5 bezienswaardigheden. Je kunt kiezen tussen een pas voor 1 dag of 2 dagen.[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fwashington-dc-l62%2Fwashington-dc-1-2-day-hop-on-hop-off-city-sights-bus-tour-t61881%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dhoponhopofwashingtontweedebutton|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#000000\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie\" font_container=\"tag:div|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_heading main_heading=\"Handige informatie\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>Ieder halte, wissel wel eerst de voucher om!</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Vanaf 9.00 uur</strong>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Enjoy the view!\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Neem plaats boven op de dubbeldekker van Big Bus\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"7106\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in Washington DC\" font_container=\"tag:div|font_size:45|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style1-left\" columns=\"4\" source=\"size:4|categories:22\"][/vc_column][/vc_row]","post_title":"Hop on Hop off Washington DC","post_link":"https://www.heyusa.com/nl/washington-dc/hop-on-hop-off/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hop on Hop off Washington\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/Hop-on-Washington3-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Washington D.C.","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1664485897627{background-color: #ededed !important;}.vc_custom_1664485277236{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1671785002:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"15","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Hop on Hop off Washington D.C.","%_yoast_wpseo_metadesc%":"De Hop on Hop off Washington D.C. is een leuke manier om de stad te verkennen. Tips voor de Hop on Hop off Washington D.C.","%_yoast_wpseo_linkdex%":"51","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"50 Massachusetts Ave NE, Washington, DC 20002, Verenigde Staten","%_wpgmp_location_city%":"Washington","%_wpgmp_location_state%":"District of Columbia","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.8978594","%_wpgmp_metabox_longitude%":"-77.0062742","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_thumbnail_id%":"7107","%_yoast_indexnow_last_ping%":"1677015506","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Bezienswaardigheden Washington D.C.","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":2235,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Union Station","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Union Station\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/Union-Station-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Union Station</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"50 Massachusetts Ave NE, Washington, D.C., DC 20002, Verenigde Staten","location":{"lat":"38.89742870000001","city":"Washington, D.C.","state":"District of Columbia","country":"Verenigde Staten","lng":"-77.0064166","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/washington-dc/union-station/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][ultimate_heading main_heading=\"Union Station in Washington\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]<span style=\"font-weight: 400;\">Een van de drukste locaties in Washington is het treinstation Union Station. Elk jaar passeren er meer dan 30 miljoen bezoekers. Tijdens de Tweede Wereldoorlog gebruikten ongeveer 200.000 mensen per dag het station, de drukste periode in het bestaan van het station. Tegenwoordig kun je er ook terecht voor een food court en een aantal winkels.\r\n</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Leuk weetje over Union Station\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">Union Station is een belangrijk station voor de wissel van locomotieven. Alle lange afstandstreinen richting Penn Station in New York moeten hun diesellocomotief inwisselen voor een elektrische. Hierdoor staat de trein langer stil in Washington.</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Union Station\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Stijlvolle stationshal\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"3533\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Achtergrond Union Station\" heading_tag=\"h3\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]<span style=\"font-weight: 400;\">Union Station was een van de eerste grote treinstations in Amerika. Daniel Burnham ontwierp het station dat in 1908 opende. De binnenkant van het station is prachtig om te bekijken door de de bogen in het station.\u00a0</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Union Station bezoeken\" heading_tag=\"h3\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]<span style=\"font-weight: 400;\">Wanneer je vanuit <a href=\"https://www.heyusa.com/nl/steden/newyorkcity/\" target=\"_blank\" rel=\"noopener noreferrer\">New York</a> richting Washington afreist met de trein, is Union Station je eerste kennismaking met Washington. Niet alleen is het een toegankelijk station, je kunt er ook nog een hapje eten. Er bevinden zich meer dan 35 <a href=\"https://www.unionstationdc.com/\" target=\"_blank\" rel=\"noopener noreferrer\">restaurants</a> in het station. Ook zijn er diverse winkels waar je nog kunt shoppen.</span>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Niet alleen de plek om de trein te pakken\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Er zitten ook vele shops en restaurants\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"3534\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Ook leuk in Washington\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:1977,1937,1953,1925\"][/vc_column][/vc_row]","post_title":"Union Station","post_link":"https://www.heyusa.com/nl/washington-dc/union-station/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Union Station\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/10/Union-Station-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Washington D.C.","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}","%_edit_last%":"1","%_edit_lock%":"1665039701:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"22","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Union Station Washington","%_yoast_wpseo_linkdex%":"78","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_title%":"%%title%% Washington %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een van de bezienswaardigheden in Washington die het bezoeken waard is Union Station. Tips voor Union Station Washington.","%_wpgmp_location_address%":"50 Massachusetts Ave NE, Washington, D.C., DC 20002, Verenigde Staten","%_wpgmp_location_city%":"Washington, D.C.","%_wpgmp_location_state%":"District of Columbia","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.89742870000001","%_wpgmp_metabox_longitude%":"-77.0064166","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"3535","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015525","taxonomy=category":"Bezienswaardigheden Washington D.C.","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":2069,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"International Spy Museum","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"International Spy Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/spy-museum-washington-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">International Spy Museum</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"700 L'Enfant Plaza SW, Washington, D.C., DC 20024, Verenigde Staten","location":{"lat":"38.8838726","city":"Washington, D.C.","state":"District of Columbia","country":"Verenigde Staten","lng":"-77.0254588","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/washington-dc/international-spy-museum-washington/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"International Spy Museum\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]<b>Wil je alles leren over spionage? Dan is het International Spy Museum in Washington echt iets voor jou! Niet alleen de geschiedenis komt aan bod, maar ook de hedendaagse spionage en natuurlijk een grote verzameling objecten omtrent spionage.</b>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"National Mall | 700 L'Enfant Plaza\"][thb_iconlist icon=\"fas fa-subway\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"L'Enfant Plaza | Orange | Silver | Blue | Green | Yellow\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Tickets? Boek deze hier!\" btn_link=\"url:https%3A%2F%2Ftickets.spymuseum.org%2Fadmissions%2FGeneralAdmission.aspx%3Fnode_id%3D1750|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Allerlei spionage gadgets\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Meer dan 750 objecten laten je kennis maken van spionage. Van foto's tot interactieve displays tot filmpjes, na een bezoek aan het museum ben je op de hoogte van alle trends rondom spionage. Het museum bevindt zich op loopafstand van de <a href=\"https://www.heyusa.com/nl/washington-dc/national-mall/\" target=\"_blank\" rel=\"noopener noreferrer\">National Mall</a> in Washington.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"De auto van James Bond\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"'s werelds bekendste spion\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"10660\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"In het International Spy Museum in Washington D.C.\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Briefing Center\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Je missie voor een bezoek aan het International Spy Museum begint in het Briefing Center. Je ontvangt een nieuwe identiteit, een RFID-enabled badge en wordt klaar gemaakt voor de test.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Making sense of secrets\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Hoe wordt geheime informatie omgezet naar actie? Probeer in het museum codes om te zetten, ga nadenken als een analist en leer van ervaren besluitvormers.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Stealing Secrets\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Kom oog in oog met spionnen, bekende spymasters, gadgetmakers en wetenschappers uit het heden en verleden. Bekijk meer dan 100 fantasierijke uitvindingen die gemaakt zijn voor spionage.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Ontdek je inner-spion\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Interactief museum in Washington\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"10662\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ook leuk in Washington:\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][fullwidth_row][thb_postgrid columns=\"4\" source=\"post_type:post|by_id:1937,1925,1910,699\"][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"International Spy Museum","post_link":"https://www.heyusa.com/nl/washington-dc/international-spy-museum-washington/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"International Spy Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/spy-museum-washington-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea Washington D.C.","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1665039175:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"21","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%_wp_old_slug%":"united-state-holocaust-memorial-museum","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"International Spy Museum in Washington","%_yoast_wpseo_title%":"%%title%% in Washington %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_linkdex%":"80","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_metadesc%":"Het International Spy Museum in Washington is een van de leukste musea om te bezoeken. Tips voor je bezoek aan het International Spy Museum.","%_wpgmp_location_address%":"700 L'Enfant Plaza SW, Washington, D.C., DC 20024, Verenigde Staten","%_wpgmp_location_city%":"Washington, D.C.","%_wpgmp_location_state%":"District of Columbia","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.8838726","%_wpgmp_metabox_longitude%":"-77.0254588","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"10661","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015526","taxonomy=category":"Musea Washington D.C.","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":2045,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"National Museum of African American History and Culture","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"National Museum of African American History and Culture\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Museum-of-African-America-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">National Museum of African American History and Culture</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1400 Constitution Ave. NW, Washington, D.C., DC 20560, Verenigde Staten","location":{"lat":"38.8910644","city":"Washington, D.C.","state":"District of Columbia","country":"Verenigde Staten","lng":"-77.032614","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/washington-dc/national-museum-african-american-history-culture/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"National Museum of African American History and Culture\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]<b>Het National Museum of African American History and Culture in Washington is gericht op de geschiedenis en cultuur van de Afro Amerikanen in Amerika. Kom alles te weten over deze gemeenschap, leer meer over slavernij en over de bijdrage van de Afro Amerikanen in de Amerikaanse samenleving.</b>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"National Mall | 1400 Constitution Avenue\"][thb_iconlist icon=\"fas fa-subway\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Federal Triangle Station | Orange | Silver | Blue\"][thb_iconlist icon=\"fas fa-dollar-sign\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Gratis\"][vc_empty_space height=\"25px\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Geopend door Barack Obama\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Na jaren van onderhandelen over de financiering en plannen van dit museum, het eerste idee was er namelijk al in 1915, werd pas in 2016 het National <a href=\"https://nmaahc.si.edu/\" target=\"_blank\" rel=\"noopener\">Museum of African American History and Culture</a> aan de <a href=\"https://www.heyusa.com/nl/washington-dc/national-mall/\" target=\"_blank\" rel=\"noopener noreferrer\">National Mall</a> geopend door Barack Obama. Een mooie start om samen te strijden tegen racisme.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"National Museum of African American History and Culture\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"De plek om meer te leren over racisme\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"10681\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"National Museum of African American History and Culture\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Slavery and Freedom\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In deze tentoonstelling wordt de complexe kant van slavernij uitgelicht. Het start in de 15e eeuw in Afrika en Europa en gaat door met de gebeurtenissen in Amerika. Door gebeurtenissen van ooggetuigen wordt deze periode heel gedetailleerd neergezet. Diverse objecten ondersteunen de verhalen.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Thannhouser Collectie\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In de tentoonstelling Sport wordt stil gestaan bij de prestaties van Afro Amerikaanse atleten op de velden en hun activisme buiten de sport. Sommige atleten zijn voorbeelden geworden voor de samenleving.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Taking the stage\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Taking the Stage verkent de geschiedenis van de Afro Amerikanen in theater, film en televisie. Niet alleen hun culturele prestaties worden ge\u00eberd, maar ook hun culturele impact wordt uitgelicht.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Het Witte Huis\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Het beroemdste huis van Amerika\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fwitte-huis-washington%2F|title:Witte%20Huis\" btn_align=\"ubtn-center\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"6928\"][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"National Museum of African American History and Culture","post_link":"https://www.heyusa.com/nl/washington-dc/national-museum-african-american-history-culture/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"National Museum of African American History and Culture\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Museum-of-African-America-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea Washington D.C.","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1665038806:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"21","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%_wp_old_slug%":"united-state-holocaust-memorial-museum","%_yoast_wpseo_focuskw%":"National Museum of African American History and Culture in Washington","%_yoast_wpseo_title%":"%%title%% in Washington%%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"In het National Museum of African American History and Culture in Washington leer je alles over de Afro Amerikanen in Amerika. Tips voor je bezoek.","%_yoast_wpseo_linkdex%":"71","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_thumbnail_id%":"3562","%_wpgmp_location_address%":"1400 Constitution Ave. NW, Washington, D.C., DC 20560, Verenigde Staten","%_wpgmp_location_city%":"Washington, D.C.","%_wpgmp_location_state%":"District of Columbia","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.8910644","%_wpgmp_metabox_longitude%":"-77.032614","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015528","taxonomy=category":"Musea Washington D.C.","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":2039,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"National Museum of American History","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"National Museum of American History in Washington\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/national-museum-american-history-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">National Museum of American History</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1300 Constitution Ave. NW, Washington, D.C., DC 20560, Verenigde Staten","location":{"lat":"38.89127930000001","city":"Washington, D.C.","state":"District of Columbia","country":"Verenigde Staten","lng":"-77.03005089999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/washington-dc/national-museum-american-history/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"De geschiedenis van Amerika\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]<b>Ben je Amerika liefhebber? Dan is het National Museum of American History in Washington geschikt voor jou! Dit museum vertelt de geschiedenis van het land net als alle ontwikkelingen die er hebben plaatsgevonden. Ook de Amerikaanse cultuur komt uitgebreid terug in het museum.</b>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"National Mall | 1300 Constitution Avenue\"][thb_iconlist icon=\"fas fa-subway\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Federal Triangle Station | Orange | Silver | Blue\"][vc_empty_space height=\"25px\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_column_text]\r\n<h4 style=\"text-align: center;\">Het museum over de Amerikaanse geschiedenis</h4>\r\n<p style=\"text-align: center;\">Het National Museum of American History is de plek voor alles wat maar met Amerika te maken heeft. Op sociaal, politiek, cultureel, wetenschappelijk en militair vlak kom je hier alles te weten. En vergeet vooral ook niet om de originele Star-Spangled Banner te bekijken in het museum!</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Wat mag je niet missen in het National Museum of American History in Washington\" font_container=\"tag:h2|font_size:50|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/4\"][vc_single_image image=\"7351\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"America on the move\" heading_tag=\"h3\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]In de loop van der jaren is er een en ander veranderd in de manier van transportatie in Amerika. In 'America on the Move' zie je alle vervoersmiddelen tussen 1876 en 1999 voorbij komen. Van de eerste trein tot de streetcar of containerboten, je vindt er meer dan 300 objecten.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][vc_single_image image=\"7353\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"First Ladies\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]Natuurlijk staat de president het vaakst in de spotlight, maar tegenwoordig zijn ook de First Ladies belangrijk. Natuurlijk kunnen de prachtige jurken die First Ladies als Jacqueline Kennedy, Laura Bush en Michelle Obama droegen niet ontbreken. Ook is er een gedeelte waarbij stil gestaan wordt bij de bijdragen van de First Ladies aan het werk van hun man.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][vc_single_image image=\"7355\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Muntenverzameling\" heading_tag=\"h3\" main_heading_font_size=\"desktop:25px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]Een collectie van meer dan 300 objecten, waaronder enkele hele zeldzame, vertellen het verhaal van het ontstaan van geld. Zo ligt er in het museum een $100.000 biljet uit 1934 en een Double Eagle munt van President Ulysses S. Grant.[/vc_column_text][/vc_column_inner][vc_column_inner thb_color=\"thb-light-column\" width=\"1/4\" css=\".vc_custom_1625317993102{padding-top: 25px !important;padding-right: 25px !important;padding-bottom: 25px !important;padding-left: 25px !important;background-color: #b34a4c !important;}\"][vc_widget_sidebar sidebar_id=\"ca-sidebar-5227\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"250px\"][ultimate_heading main_heading=\"Het Witte Huis\" main_heading_color=\"#ffffff\" sub_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\" sub_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" sub_heading_style=\"font-weight:300;\" sub_heading_font_size=\"desktop:35px;\"]Het woon-en werk huis van de Amerikaanse president[/ultimate_heading][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fwitte-huis-washington%2F|title:Witte%20Huis%20Washington\" btn_align=\"ubtn-center\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:25px;\"][vc_empty_space height=\"250px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"5300\"][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"National Museum of American History","post_link":"https://www.heyusa.com/nl/washington-dc/national-museum-american-history/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"National Museum of American History in Washington\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/national-museum-american-history-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea Washington D.C.","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}.vc_custom_1625317993102{padding-top: 25px !important;padding-right: 25px !important;padding-bottom: 25px !important;padding-left: 25px !important;background-color: #b34a4c !important;}","%_edit_lock%":"1665038486:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"21","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%_wp_old_slug%":"united-state-holocaust-memorial-museum","%_yoast_wpseo_focuskw%":"National Museum of American History in Washington","%_yoast_wpseo_title%":"%%title%% in Washington %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Het National Museum of American History in Washington vertelt je de geschiedenis van Amerika. Tips voor je bezoek aan het museum.","%_yoast_wpseo_linkdex%":"74","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"1300 Constitution Ave. NW, Washington, D.C., DC 20560, Verenigde Staten","%_wpgmp_location_city%":"Washington, D.C.","%_wpgmp_location_state%":"District of Columbia","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.89127930000001","%_wpgmp_metabox_longitude%":"-77.03005089999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_thumbnail_id%":"7349","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015530","taxonomy=category":"Musea Washington D.C.","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":2006,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"United States Holocaust Memorial Museum","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"United States Holocaust Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Holocaust-Museum2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">United States Holocaust Memorial Museum</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"100 Raoul Wallenberg Pl SW, Washington, D.C., DC 20024, Verenigde Staten","location":{"lat":"38.8867076","city":"Washington, D.C.","state":"District of Columbia","country":"Verenigde Staten","lng":"-77.0326074","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/washington-dc/united-states-holocaust-memorial-museum/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"United States Holocaust Memorial Museum\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]<b>Hoewel het United States Holocaust Memorial Museum in Washington geen onderdeel uitmaakt van het Smithsonian Institute, ligt het net als vele andere musea in Washington ook nabij de <a href=\"https://www.heyusa.com/nl/washington-dc/national-mall/\" target=\"_blank\" rel=\"noopener noreferrer\">National Mall</a>. In het museum vind je alle informatie over de Holocaust, van de macht door de nazi's in 1933 tot de bevrijding van de concentratiekampen in 1945. Wat mag je niet missen in het Holocaust Museum?</b>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"National Mall | 100 Raoul Wallenberg Pl SW\"][thb_iconlist icon=\"fas fa-subway\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"L'Enfant Plaza | Yellow | Orange | Silver | Blue | Green\"][thb_iconlist icon=\"fas fa-dollar-sign\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Gratis\"][vc_empty_space height=\"25px\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Sta stil bij de gebeurtenissen in de Holocaust\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Naast de permanente tentoonstelling over de <a href=\"https://www.ushmm.org/\" target=\"_blank\" rel=\"noopener\">Holocaust</a> is het museum de plek voor de documentatie van de Holocaustoverlevenden. Een register bevat meer dan 195.000 namen van overlevenden en hun familieleden. Leer over de Holocaust en sta stil bij de gebeurtenissen van tijdens de Holocaust.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"H\u00e9t museum over de Holocaust\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Indrukwekkende verhalen over de Holocaust\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"3557\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Wat mag je niet missen in het United States Holocaust Memorial Museum\" font_container=\"tag:h2|font_size:50|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"3560\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Tower of faces\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]In de permanente tentoonstelling Tower of Faces, vind je een toren van ruim 3 meter hoog met daarop meer dan 1000 foto's van het dagelijks leven voor de Holocaust in het Litouwse dorpje Eisiskes. Het dorpje had zo'n 3500 inwoners die voornamelijk Joods waren en zij werden gedurende de oorlog systematisch uitgeroeid.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"3559\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Permanente tentoonstelling: Holocaust\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]In chronologische volgorde van verschillende gebeurtenissen tijdens de oorlog ontdek je wat er zich allemaal heeft afgespeeld tijdens de Holocaust. Door middel van afbeeldingen, voorwerpen, films en verhalen word je meegenomen in de gebeurtenissen.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"3556\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Verhalen door een Holocaust overlevende\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]In het hoogseizoen kun je luisteren naar de verhalen van een Holocaust overlevende. Wat is er indrukwekkender dan te luisteren naar verhalen van mensen die de Holocaust daadwerkelijk mee hebben gemaakt?[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Het Witte Huis\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Het beroemdste huis van Amerika\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fwitte-huis-washington%2F|title:Witte%20Huis\" btn_align=\"ubtn-center\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"6928\"][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"United States Holocaust Memorial Museum","post_link":"https://www.heyusa.com/nl/washington-dc/united-states-holocaust-memorial-museum/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"United States Holocaust Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Holocaust-Museum2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea Washington D.C.","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1665038262:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"21","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%_wp_old_slug%":"united-state-holocaust-memorial-museum","%_yoast_wpseo_focuskw%":"United States Holocaust Memorial Museum in Washington","%_yoast_wpseo_title%":"%%title%% in Washington %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Het United States Holocaust Memorial Museum in Washington laat je kennis maken met de Holocaust. Tips voor je bezoek aan het Holocaust Museum","%_yoast_wpseo_linkdex%":"73","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"100 Raoul Wallenberg Pl SW, Washington, D.C., DC 20024, Verenigde Staten","%_wpgmp_location_city%":"Washington, D.C.","%_wpgmp_location_state%":"District of Columbia","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.8867076","%_wpgmp_metabox_longitude%":"-77.0326074","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"3558","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015533","taxonomy=category":"Musea Washington D.C.","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":2000,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"National Museum of Natural History","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"National Museum of Natural History in Washington DC\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Museum-of-natural-history4-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">National Museum of Natural History</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"10th St. & Constitution Ave. NW, Washington, D.C., DC 20560, Verenigde Staten","location":{"lat":"38.8912662","city":"Washington, D.C.","state":"District of Columbia","country":"Verenigde Staten","lng":"-77.0260654","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/washington-dc/national-museum-of-natural-history/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"National Museum of Natural History\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]<b>Een van de meest bezochte Smithsonian Musea is het National Museum of Natural History in Washington. Het is dan ook 's werelds grootste natuurhistorische museum en staat het op de elfde plek van de meest bezochte musea ter wereld. Kortom een museum met veel informatie en interactie voor iedere doelgroep!</b>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"National Mall | 10th &amp; Constitution Avenue\"][thb_iconlist icon=\"fas fa-subway\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Federal Triangle Station | Blue | Orange | Silver\"][thb_iconlist icon=\"fas fa-dollar-sign\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Gratis\"][vc_empty_space height=\"25px\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ontdek het grootste natuurhistorische museum\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Ontdek in het meest bezochte natuurhistorische museum alles over de dieren die leefden op aarde of in de oceanen. In het <a href=\"https://naturalhistory.si.edu/\" target=\"_blank\" rel=\"noopener\">National Museum of Natural History</a> vind je niet alleen meer dan 145 miljoen exemplaren van planten, fossiele, dieren, mineralen, gesteenten en meteorieten, maar ook meer dan honderd levende vlinders.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Levensgrote skeletten\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Wandel tussen de eeuwenoude skeletten\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"3553\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Wat mag je niet missen in het National Museum of Natural History in Washington\" font_container=\"tag:h2|font_size:50|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"3552\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Dinosaurussen\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Enorme skeletten van dinosauri\u00ebrs staan in de Hall of Paleobiology. Zo kun je zien hoe groot een Brontotherium is of een Tyrannosaurus. Er staan meer dan 40 complete skeletten in de hal. Een bezoek aan de tentoonstelling met alle dinosauri\u00ebrs kan dus niet ontbreken in het museum.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"3551\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Afrikaanse Bush olifant\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Een bijna 4 meter hoge olifant is de grote publiekstrekker op de eerste etage. Henry zoals hij genoemd wordt, is ongeveer 11.000 kilo. Bij de tentoonstelling leer je alles over olifanten, hoe ze communiceren, wat ze eten en kun je via beelden zien hoe deze enorme beesten in het echt leven.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"7369\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Vlinderpaviljoen\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]De meeste objecten in het National Museum of Natural History zijn niet meer in leven op de vlinder in het vlinderpaviljoen na. In het vlinder paviljoen vind je meer dan honderd levende vlinders. Hier vind je het ideale klimaat voor vele verschillende soorten vlinders.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"National Mall\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Must see in Washington\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fwashington-dc%2Fnational-mall%2F|title:National%20Mall\" btn_align=\"ubtn-center\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"3797\"][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"National Museum of Natural History","post_link":"https://www.heyusa.com/nl/washington-dc/national-museum-of-natural-history/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"National Museum of Natural History in Washington DC\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Museum-of-natural-history4-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea Washington D.C.","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1665038311:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"21","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%_yoast_wpseo_focuskw%":"National Museum of Natural History in Washington","%_yoast_wpseo_title%":"%%title%% in Washington %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Het National Museum of Natural History in Washington is het grootste natuurhistorische museum ter wereld. Tips voor je bezoek.","%_yoast_wpseo_linkdex%":"79","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"10th St. & Constitution Ave. NW, Washington, D.C., DC 20560, Verenigde Staten","%_wpgmp_location_city%":"Washington, D.C.","%_wpgmp_location_state%":"District of Columbia","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.8912662","%_wpgmp_metabox_longitude%":"-77.0260654","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"3554","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015535","taxonomy=category":"Musea Washington D.C.","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":1992,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"National Museum of the American Indian","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"National Museum of the American Indian\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Museum-of-the-American-Indian-2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">National Museum of the American Indian</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"4th St SW, Washington, D.C., DC 20560, Verenigde Staten","location":{"lat":"38.8883484","city":"Washington, D.C.","state":"District of Columbia","country":"Verenigde Staten","lng":"-77.01650339999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/washington-dc/national-museum-of-the-american-indian/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"National Museum of the American Indian\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]<b>Net als de meeste musea in Washington is ook het National Museum of the American onderdeel van het Smithsonian Institute. In het museum vind je alles over inheemse volkeren van het westelijk halfrond. Het gebouw op zich is al prachtig om te zien. De ronde vormen zijn ge\u00efnspireerd op de Blackfoot- en Metis achtergrond van de architect. Tips voor je bezoek aan het museum.</b>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"National Mall | Independence Avenue SW\"][thb_iconlist icon=\"fas fa-subway\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Federal Center SW | Blue | Orange | Silver\"][thb_iconlist icon=\"fas fa-subway\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Federal Center SW | Blue | Orange | Silver\"][vc_empty_space height=\"25px\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Leer meer over de inheemse volkeren\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Het grootste deel van de collectie in het museum komt uit de verzameling van George Gustav Heye die zelf begon met het verzamelen van voorwerpen uit inheemse Amerikaanse culturen. Een deel van zijn collectie is ook in het <a href=\"https://americanindian.si.edu/\" target=\"_blank\" rel=\"noopener\">Museum of the American India</a>n in New York te zien. De collectie in Washington is opgedeeld in verschillende gebieden. Je hebt niet alleen tentoonstellingen over Amerikaanse gebieden, maar ook over onder andere Patagoni\u00eb, Amazone en de Andes.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Museum over inheemse culturen\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Grote collectie over verschillende inheemse culturen over de hele wereld\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"3546\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Wat mag je niet missen in het National Museum of the American Indian\" font_container=\"tag:h2|font_size:50|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"3547\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Californi\u00eb - Great Basin\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]De archeologische collecties over <a href=\"https://www.heyusa.com/nl/tag/californie/\">Californi<span lang=\"nl\">\u00eb</span></a> zijn groot. Vooral van de plekken in het zuiden van Californi<span lang=\"nl\">\u00eb </span>en de eilanden zijn veel voorwerpen gevonden en uiteindelijk tentoongesteld in het museum.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"3548\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Northwest collectie\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]In de collectie die verzameld is in de Northwest Coast regio worden alle stammen die er destijds leefden of nu nog leven vertegenwoordigd. Diverse voorwerpen laten zien hoe de inheemse volkeren leefden, de meeste objecten zijn verzameld tijdens de Harriman expeditie in 1899. Van de periode na 1930 zijn helaas weinig items tentoongesteld.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"3549\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"American Art\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Het National Museum of the American Indian probeert ook de hedendaagse kunst van inheemse culturen tentoon te stellen. Schilderijen, tekeningen en sculpturen gemaakt door native kunstenaars uit de twintigste eeuw zijn een belangrijk onderdeel van het museum.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Witte Huis\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Het beroemdste huis van Amerika\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fwitte-huis-washington%2F|title:Witte%20Huis\" btn_align=\"ubtn-center\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"6928\"][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"National Museum of the American Indian","post_link":"https://www.heyusa.com/nl/washington-dc/national-museum-of-the-american-indian/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"National Museum of the American Indian\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Museum-of-the-American-Indian-2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea Washington D.C.","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1665038319:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"21","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%_yoast_wpseo_focuskw%":"National Museum of the American Indian","%_yoast_wpseo_title%":"%%title%% in Washington%%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Het National Museum of the American Indian in Washington toont je alles over inheemse volkeren. Tips voor je bezoek aan het museum.","%_yoast_wpseo_linkdex%":"81","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"4th St SW, Washington, D.C., DC 20560, Verenigde Staten","%_wpgmp_location_city%":"Washington, D.C.","%_wpgmp_location_state%":"District of Columbia","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.8883484","%_wpgmp_metabox_longitude%":"-77.01650339999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"3545","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015537","taxonomy=category":"Musea Washington D.C.","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":1989,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"National Air and Space Museum","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"National Air and Space Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/National-Air-and-space-museum2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">National Air and Space Museum</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"600 Independence Ave SW, Washington, D.C., DC 20560, Verenigde Staten","location":{"lat":"38.88816010000001","city":"Washington, D.C.","state":"District of Columbia","country":"Verenigde Staten","lng":"-77.0198679","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/washington-dc/national-air-space-museum/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Het National Air and Space Museum\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]<strong>Het National Air and Space Museum in Washington heeft de grootste collectie vlieg- en ruimtevaarttuigen ter wereld. Het museum maakt onderdeel uit van het Smithsonian Institution in Washington. Omdat het museum naast het <a href=\"https://www.heyusa.com/nl/washington-dc/capitool-washington/\" target=\"_blank\" rel=\"noopener noreferrer\">Capitool</a> staat, wilden ze graag een architectonisch indrukwekkend gebouwd lijkt het enigszins op het Capitool. Wanneer je er voor staat zie je ook echt de gelijknissen tussen beide gebouwen. Benieuwd wat je niet mag missen in het museum?</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"National Mall | 600 Independence Ave SW\"][thb_iconlist icon=\"fas fa-subway\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Federal Center SW | Blue | Orange | Silver\"][thb_iconlist icon=\"fas fa-dollar-sign\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Gratis\"][vc_empty_space height=\"25px\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Leer meer over geschiedenis, onderzoek en technologie in de vliegwereld\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Naast de grote collectie vlieg- en ruimtevaartuigen is het <a href=\"https://airandspace.si.edu/\" target=\"_blank\" rel=\"noopener\">National Air and Space Museum</a> ook een plek waar onderzoek gedaan wordt, waar je meer te weten komt over de geschiedenis en technologie van de ruimtevaart. Ontdek de geschiedenis van de ruimtevaart in het museum.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Talloze vliegtuigen\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Indrukwekkende collectie om onder door te wandelden\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"3540\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Wat mag je niet missen in het National Air &amp; Space Museum in Washington\" font_container=\"tag:h2|font_size:50|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"3542\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Apollo 11\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Apollo 11 was de wereldbekende missie die de eerste man op de maan zette. De bemanning van Apollo 11 bestond uit Neil Armstrong, Edwin Aldrin en Michael Collins. In het museum bevinden zich meer dan 3500 attributen van deze missie. Een kleine selectie van deze Apollo 11 objecten is te zien in het museum.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"3543\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Mercury MA-6\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]De Mercury MA-6 is de derde ruimtevlucht in het kader van het Mercury programma. De Friendship 7 capsule, met aan boord John Glenn, vloog in een baan om de wereld. De vlucht werd baanbrekend omdat men na die tijd wist dat 5 uur gewichtloosheid geen nadelige medische gevolgen had.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"3539\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Wright Flyer\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Het vliegen in de wereld begon allemaal met de gebroeders Wright in 1903. In dit jaar werd de eerste succesvolle vlucht gemaakt. Het vliegtuig dat de broers Wright bouwden staat in het museum. Als liefhebber van vliegtuigen mag je dit stukje historie niet missen![/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Lincoln Memorial\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Indrukwekkend memorial van oud president Abraham Lincoln\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Flincoln-memorial-washington%2F|title:Lincoln%20Memorial\" btn_align=\"ubtn-center\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"709\"][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"National Air and Space Museum","post_link":"https://www.heyusa.com/nl/washington-dc/national-air-space-museum/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"National Air and Space Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/National-Air-and-space-museum2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea Washington D.C.","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1665039329:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"21","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%_yoast_wpseo_focuskw%":"National Air and Space Museum in Washington","%_yoast_wpseo_title%":"%%title%% in Washington%%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"In het National Air and Space Museum in Washington vind je alles over de lucht- en ruimtevaart. Tips voor je bezoek aan het museum.","%_yoast_wpseo_linkdex%":"75","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"600 Independence Ave SW, Washington, D.C., DC 20560, Verenigde Staten","%_wpgmp_location_city%":"Washington, D.C.","%_wpgmp_location_state%":"District of Columbia","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.88816010000001","%_wpgmp_metabox_longitude%":"-77.0198679","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"3541","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015539","taxonomy=category":"Musea Washington D.C.","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":1977,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Witte Huis Washington","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Witte huis\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/witte-huis-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Witte Huis Washington</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1600 Pennsylvania Avenue NW, Washington, D.C., DC 20500, Verenigde Staten","location":{"lat":"38.8976763","city":"Washington, D.C.","state":"District of Columbia","country":"Verenigde Staten","lng":"-77.0365298","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/witte-huis-washington/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][ultimate_heading main_heading=\"Witte Huis in Washington\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]<span style=\"font-weight: 400;\">Een van de grootste trekpleisters is het Witte Huis in Washington. Ook niet gek als je bedenkt dat misschien wel de belangrijkste man van Amerika er woont. Vanaf de buitenkant ziet het Witte Huis er eigenlijk uit als een normaal huis en dat is niet gek, want er woont natuurlijk ook gewoon een familie. De totale oppervlakte van het Witte Huis is meer dan 5000 m2. Met een beetje geluk kun je binnen kijken in het huis waar zoveel Amerikaanse geschiedenis is geschreven.\r\n</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar te bekijken\r\nTours vrijdag en zaterdag 8.00 -11.00 uur[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Gratis[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Tips om het Witte Huis te bekijken\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">Vanaf <a href=\"https://www.heyusa.com/nl/washington-dc/national-mall/\" target=\"_blank\" rel=\"noopener noreferrer\">The National Mall</a> kun je gemakkelijk naar het Witte Huis lopen. Het Witte Huis is vrijwel altijd te bekijken vanaf de buitenkant. De enige gelegenheden wanneer er strenge bewaking is rondom het Witte Huis, is wanneer de helikopter van de president aankomt of vertrekt. Hierdoor kan het zijn dat je niet zo dicht bij mag komen (loop in dit geval wel een rondje om het Witte Huis, aan de achterkant kun je vaak nog even kijken). Normaal gesproken kun je de buitenkant altijd aanschouwen. Loop een rondje om het terrein rondom het Witte Huis en je krijgt een idee hoe groot het eigenlijk is.\u00a0</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Het Witte Huis\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Het belangrijkste huis in Amerika\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"5295\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Weetjes over het Witte Huis\" heading_tag=\"h3\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]<span style=\"font-weight: 400;\">Na een periode van 8 jaar bouwen, staat sinds 1800 staat het Witte Huis in Washington. Het gebouw bestaat uit die verschillende delen: het hoofdgebouw, een westelijke en oostelijke vleugel. De priv\u00e9 vertrekken bevinden zich in het hoofdgebouw. Wanneer je het Witte Huis mag bezoeken, dan kom je alleen in de oostelijke vleugel. Het westelijke deel van het Witte Huis is het werkterrein van de president. Niet alleen de Oval Office zit hier, maar ook de Situation Room. Oh en er bevinden zich ook nog 132 andere kamers, 28 open haarden, 1 bowlinghal, 1 filmzaal, 1 zwembad, 1 basketbalveld en 1 tennisveld op een van de zes verdiepingen.\r\n</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Hoe ga je mee met een tour door het Witte Huis?\" heading_tag=\"h3\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]<span style=\"font-weight: 400;\">Oke, direct maar de waarheid; het is lastig om met een tour binnen te komen in het Witte Huis. Om het <a href=\"https://www.whitehouse.gov/\" target=\"_blank\" rel=\"noopener noreferrer\">Witte Huis</a> te bekijken moet je als buitenlander contact opnemen met je eigen ambassade die je gaat helpen met het doen van aanvraag bij een Member of Congress. Verzoeken kunnen vanaf 3 maanden tot 21 dagen voor je bezoek. De tours zijn alleen op vrijdag en zaterdag tussen 8.00 en 11.00 uur. En eigenlijk heb je na bevestiging nog niet altijd de zekerheid om het Witte Huis te bezoeken, een tour kan nog gecanceld worden door omstandigheden. Kortom, een lastig karwei! Maar wie weet ben je een van de gelukkige deelnemers die het Witte Huis van binnen mag bekijken.\r\n</span>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"De ambtswoning van de president\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Wat er achter de schermen gebeurt weet bijna niemand\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"5288\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][ultimate_heading main_heading=\"Ook leuk in Washington\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:1937,1925,1977,699\"][/vc_column][/vc_row]","post_title":"Witte Huis Washington","post_link":"https://www.heyusa.com/nl/witte-huis-washington/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Witte huis\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/witte-huis-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden Washington D.C.","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1665045161:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"22","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_yoast_wpseo_focuskw%":"Witte Huis in Washington","%_yoast_wpseo_title%":"Het Witte Huis in Washington%%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Het meest bekende huis van Amerika: Het Witte Huis in Washington. Tips voor je bezoek aan het Witte Huis en leuke weetjes over het Witte Huis","%_yoast_wpseo_linkdex%":"80","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"1600 Pennsylvania Avenue NW, Washington, D.C., DC 20500, Verenigde Staten","%_wpgmp_location_city%":"Washington, D.C.","%_wpgmp_location_state%":"District of Columbia","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"38.8976763","%_wpgmp_metabox_longitude%":"-77.0365298","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_thumbnail_id%":"6928","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015542","taxonomy=category":"Bezienswaardigheden Washington D.C.","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":1910,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Grand Central Terminal","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Grand Central Terminal\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Grand-Central-Terminal-balkon-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Grand Central Terminal</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"89 E 42nd St, New York, NY 10017, Verenigde Staten","location":{"lat":"40.75272619999999","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.9772294","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/grand-central-terminal-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"25px\"][vc_custom_heading text=\"Grand Central Terminal in New York\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Grand Central Terminal in New York is voor velen geen onbekende bezienswaardigheid. Decor voor vele <a href=\"https://www.heyusa.com/nl/filmklassiekers-die-zich-in-new-york-afspelen/\" target=\"_blank\" rel=\"noopener\">films</a> en series en daardoor lijkt het alsof je hier eerder geweest bent. En hoewel je, naast de foodhall, er eigenlijk geen bezienswaardigheden vindt, is het toch een aanrader om te bezoeken. Al is het alleen maar om even door heen te lopen of plaats te nemen op een van de balkons om mensen te kijken.\r\n</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend - 05.30\u00a0 tot 02.00 uur[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Gratis[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-map-marker\"]East 42nd Street &amp; Park Avenue[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-subway\"]Grand Central Terminal - 4 | 5 | 6 | 7 | S[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1640070748004{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Tips voor je bezoek aan Grand Central Terminal\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">Hoewel de meeste treinen inmiddels vanaf Penn Station vertrekken, blijft het Grand Central Station een icoon in New York. De grote hal, met in het midden een klok, is alleen al prachtig om te bekijken. De lichtinval door de grote ramen maakt het tot een fotogenieke locatie.</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Het grootste treinstation ter wereld\" font_container=\"tag:div|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"1893\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Weetjes over Grand Central Terminal\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Verbaas je niet, maar het Grand Central is het grootste treinstation ter wereld. Het bestaat uit maar liefst 44 perrons en 67 sporen. Het station werd geopend in oktober 1871, maar het huidige gebouw heeft pas sinds 1913 deze vorm. En hoewel het het grootste station ter wereld is passeren er 'slechts' zo'n 500.000 bezoekers per dag (in Japan ligt dit in de miljoenen).\r\n</span>\r\n\r\nEr is ook een geheim perron naar het Waldorf Astoria. President Roosevelt gebruikte dit spoor om journalisten te ontwijken.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Verborgen plekje op het Grand Central Terminal in New York\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Er bevindt zich in Grand Central een fluistergalerij. Iets dat je waarschijnlijk moeilijk kunt geloven, maar vlak bij de <a href=\"https://www.oysterbarny.com/\" target=\"_blank\" rel=\"noopener noreferrer\">Oyster Bar</a> kun je met elkaar praten wanneer je beiden plaatsneemt in een hoek. Heel onwerkelijk wanneer er ondertussen honderden mensen langslopen!</span>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1646220436260{padding-top: 100px !important;padding-bottom: 75px !important;background-color: #b34a4c !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/4\"][vc_single_image image=\"5370\" img_size=\"375x375\"][/vc_column_inner][vc_column_inner width=\"1/2\"][thb_title style=\"style9\" text_align=\"text-left\" bg_color=\"#531a23\" title=\"Extra tip: Grand Central Terminal Secrets tour\"][vc_custom_heading text=\"Ontdek de geheimen van Grand Central Terminal\" font_container=\"tag:h2|font_size:22|text_align:left|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Tijdens een wandeltocht ontdek je de verborgen schatten van Grand Central Terminal. Bekijk verboden glazen loopbruggen, de Tiffany klok, ontwerpfouten en verborgen juwelen. Daarnaast hoor je meer over de geschiedenis van het station.\" font_container=\"tag:p|font_size:15|text_align:left|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Roboto%3A100%2C100italic%2C300%2C300italic%2Cregular%2Citalic%2C500%2C500italic%2C700%2C700italic%2C900%2C900italic|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"10\"][ultimate_icon_list_item icon=\"Defaults-group users\" icon_color=\"#ffffff\" content_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" content_font_style=\"font-weight:800;\" content_font_color=\"#ffffff\"]Kleine groepen[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\" icon_color=\"#ffffff\" content_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" content_font_style=\"font-weight:800;\" content_font_color=\"#ffffff\"]Duurt 1,5 uur[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-compass\" icon_color=\"#ffffff\" content_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" content_font_style=\"font-weight:800;\" content_font_color=\"#ffffff\"]Inclusief gids[/ultimate_icon_list_item][/ultimate_icon_list][ult_buttons btn_title=\"BOEK DEZE TOUR\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fnyc-the-secrets-of-grand-central-terminal-t325018%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dgrandcentralterminalsecretstour|title:BOEK%20DEZE%20TOUR|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#7f9c76\" btn_bg_color=\"#ffffff\" btn_title_color_hover=\"#253d39\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\" btn_line_height=\"desktop:23px;\"][/vc_column_inner][vc_column_inner width=\"1/4\"][vc_custom_heading text=\"VANAF\" font_container=\"tag:p|font_size:12|text_align:left|color:%23ffffff|line_height:0\" google_fonts=\"font_family:Roboto%3A100%2C100italic%2C300%2C300italic%2Cregular%2Citalic%2C500%2C500italic%2C700%2C700italic%2C900%2C900italic|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"\u20ac34,-\" font_container=\"tag:p|font_size:30|text_align:left|color:%23ffffff|line_height:0%2C5\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"per persoon\" font_container=\"tag:p|font_size:12|text_align:left|color:%23ffffff|line_height:0\" google_fonts=\"font_family:Roboto%3A100%2C100italic%2C300%2C300italic%2Cregular%2Citalic%2C500%2C500italic%2C700%2C700italic%2C900%2C900italic|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Enjoy the view!\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][vc_custom_heading text=\"Uitzicht vanaf het balkon\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"1896\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York City:\" font_container=\"tag:div|font_size:45|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"25px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:1559,1484,557,506\"][/vc_column][/vc_row]","post_title":"Grand Central Terminal","post_link":"https://www.heyusa.com/nl/grand-central-terminal-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Grand Central Terminal\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Grand-Central-Terminal-balkon-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1640070748004{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1646220436260{padding-top: 100px !important;padding-bottom: 75px !important;background-color: #b34a4c !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1668004259:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"14","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Grand Central Terminal in New York","%_yoast_wpseo_title%":"%%title%% in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Grand Central Terminal New York is een leuke bezienswaardigheid om te bezoeken. Alle tips voor een bezoek aan GCT in New York.","%_yoast_wpseo_linkdex%":"75","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"89 E 42nd St, New York, NY 10017, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.75272619999999","%_wpgmp_metabox_longitude%":"-73.9772294","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_thumbnail_id%":"5371","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1677015545","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Bezienswaardigheden New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":1886,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"The Vessel bezoeken in Hudson Yards","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Vessel\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/The-Vessel-2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">The Vessel bezoeken in Hudson Yards</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"Boottocht van 90 minuten over de Hudson en East River","address":"20 Hudson Yards, New York, NY 10001, Verenigde Staten","location":{"lat":"40.7538073","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-74.0021537","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/the-vessel-hudson-yards/","zoom":12,"extra_fields":{"post_excerpt":"Boottocht van 90 minuten over de Hudson en East River","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"30px\"][vc_custom_heading text=\"The Vessel bezoeken in de nieuwe wijk Hudson Yards\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Een van de leukste en redelijk nieuwe bezienswaardigheden in New York is The Vessel in Hudson Yards. In de wijk Hudson Yards vind je tegenwoordig allemaal hoogtepunten die de moeite waard zijn. Zo ook The Vessel. Het gebouw bestaat volledig uit trappen en platforms die met elkaar in verbinding zijn, een architectonisch hoogtepunt!</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-arrows-v\"]46 meter hoog[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-building\"]16 verdiepingen[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]$10 per persoon[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-group users\"]Minimaal 2 personen, solo bezoek niet mogelijk[/ultimate_icon_list_item][/ultimate_icon_list][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.hudsonyardsnewyork.com%2Fdiscover%2Fvessel|title:Bestel%20je%20tickets\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612949537564{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Over The Vessel in Hudson Yards\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">The Vessel is een apart gebouw om te bekijken. Allemaal verschillende trappen die verschillende platformen verbinden. Het is alleen al prachtig om te bekijken! Je kan maar liefst 2500 treden beklimmen als je helemaal rondloopt. Pauze kun je nemen op een van de 80 uitkijk-platforms. Vanaf hier heb je een prachtig uitzicht over The Vessel zelf, maar ook over <a href=\"https://www.heyusa.com/nl/newyork/newyorkcity/buurten/hudson-yards/\" target=\"_blank\" rel=\"noopener noreferrer\">Hudson Yards</a>.</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"46m hoog\" font_container=\"tag:div|font_size:75|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"... en heel veel trappen omhoog!\" font_container=\"tag:div|font_size:45|text_align:center\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"1872\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tickets voor The Vessel\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Om de The Vessel te bezoeken, heb je een online nodig, deze moet je vooraf reserveren. Je krijgt dan een tijdslot van 10 minuten waarop je naar binnen mag. Je kunt twee weken van te voren tickets boeken. Na de tragische zelfmoorden, is het niet meer mogelijk om solo The Vessel te bezoeken, toegang is minimaal per 2 personen.</span>\r\n\r\n<span style=\"font-weight: 400;\"><a href=\"https://www.hudsonyardsnewyork.com/discover/vessel\" target=\"_blank\" rel=\"noopener noreferrer\">Tickets</a> voor de dag zelf zijn vanaf 9.30 uur online te bestellen of te verkrijgen bij de kiosks op 20 <a href=\"https://www.heyusa.com/nl/newyork/newyorkcity/buurten/hudson-yards/\" target=\"_blank\" rel=\"noopener noreferrer\">Hudson Yards</a>. Hierbij geldt wel wie het eerste komt, heeft de meeste kans.\u00a0</span>[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.hudsonyardsnewyork.com%2Fdiscover%2Fvessel\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"1/2\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Met zonsopkomst en zonsondergang heb je het mooiste licht om foto's te maken.\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>30th &amp; 34th Street - 10th &amp; 11th Avenue</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Dagelijks van 10.00 - 21.oo uur. In de winter tot 19.00 uur.</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-subway\"]<strong>Hudson Yards - 7</strong>[/ultimate_icon_list_item][/ultimate_icon_list][vc_custom_heading text=\"Wat is het beste moment om The Vessel te bezoeken?\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Hoewel het altijd druk is op het plein rondom The Vessel heb je niet met wachttijden te maken omdat je met time-slots werkt.\u00a0</span><span style=\"font-weight: 400;\">\r\n</span><span style=\"font-weight: 400;\">\r\n</span><b>De beste tijden om The Vessel te bezoeken:\u00a0</b>\r\n<ul>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Weinig tot geen wachtrijen gedurende de gehele dag</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Een uur voor schemering, je hebt dan dag- en avond in 1x!</span></li>\r\n</ul>\r\n[/vc_column_text][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"5/6\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Bezoek ook The Edge wanneer je wel van een uitdaging houdt op loop The High Line af naar Chelsea.\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Enjoy the view!\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_custom_heading text=\"Midtown Manhattan vanaf The Vessel\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:3\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"1880\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:298,1784,1571,506\"][/vc_column][/vc_row]","post_title":"The Vessel bezoeken in Hudson Yards","post_link":"https://www.heyusa.com/nl/the-vessel-hudson-yards/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Vessel\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/The-Vessel-2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1612949537564{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}","%_edit_last%":"1","%_edit_lock%":"1659515624:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"15","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"1879","%_yoast_wpseo_focuskw%":"The Vessel in Hudson Yards","%_yoast_wpseo_title%":"The Vessel in Hudson Yards %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een leuke en gratis bezienswaardigheid in Hudson Yards is The Vessel. Alle tips voor je bezoek aan The Vessel in New York.","%_yoast_wpseo_linkdex%":"76","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"20 Hudson Yards, New York, NY 10001, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7538073","%_wpgmp_metabox_longitude%":"-74.0021537","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_indexnow_last_ping%":"1677015547","taxonomy=category":"Bezienswaardigheden New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":1875,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Governors Island","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Governor Island\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Governor-Island-boot-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Governors Island</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Governors Island, New York City, New York 11231, Verenigde Staten","location":{"lat":"40.68945009999999","city":"New York City","state":"New York","country":"Verenigde Staten","lng":"-74.016792","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/governors-island-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"25px\"][vc_custom_heading text=\"Wat te doen op Governors Island New York?\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<div class=\"wpb_text_column wpb_content_element \">\r\n<div class=\"wpb_wrapper\">\r\n\r\nEen van New Yorks goed bewaarde geheimen is toch wel Governors Island, het kleine eiland voor de kust van Lower Manhattan. Een groen en rustig park vanwaar je ook nog eens een fantastisch uitzicht hebt over de skyline van New York. Governors Island is alleen in de zomermaanden toegankelijk met een <a href=\"https://www.heyusa.com/nl/new-york-city/nyc-ferry/\" target=\"_blank\" rel=\"noopener noreferrer\">ferry</a> vanaf <a href=\"https://www.heyusa.com/nl/newyork/newyorkcity/buurten/lower-manhattan/\" target=\"_blank\" rel=\"noopener noreferrer\">Lower Manhattan</a> en het is alsof je in een andere wereld bent. Geen drukte van Manhattan om je heen, dus tijd om even te relaxen.\r\n\r\n</div>\r\n</div>\r\n<div class=\"wpb_text_column wpb_content_element \">\r\n<div class=\"wpb_wrapper\"></div>\r\n</div>\r\n<span style=\"font-weight: 400;\">\u00a0</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]In de zomermaanden[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf $3 per persoon[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Over Governors Island\" font_container=\"tag:h2|font_size:40|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">In de zomer kun je Governors Island zeven dagen per week bezoeken met een ferry. Het eiland is ongeveer 70 hectare groot en in de zomer een plek waar de New Yorkers graag komen. Vroeger werd het eiland gebruikt voor militaire doeleinden en dat is nog steeds te zien op het eiland. Op Governors Island staan nog een oud fort en een kasteel uit deze periode.\r\nHet eiland is in de zomermaanden de perfecte plek voor om te picknicken of te relaxen. En dat kun je allemaal doen met een uitzicht op het Vrijheidsbeeld en Manhattan. Daarnaast zijn er nog genoeg andere leuke dingen om te doen op Governor Island.</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Noten Eylandt\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"De koloniale Nederlandse naam van het eiland\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"1855\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"De leukste dingen om te doen op Governors Island\" font_container=\"tag:h2|font_size:40|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"25px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"10232\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][vc_custom_heading text=\"Fietsen op Governor Island\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Je kunt een redelijk eind komen zonder fiets, want wandelen kan ook prima op Governors Island. Toch kun je met een fiets net even wat meer zien van het eiland. Het huren van een fiets is de makkelijkste optie, een eventueel gehuurde fiets in Manhattan mag ook mee met de ferry. Voor ongeveer $15 kun je een fiets huren voor twee uur.</span>\r\n\r\n[/vc_column_text][ult_buttons btn_title=\"Reserveer hier je fiets\" btn_link=\"url:https%3A%2F%2Fwww.blazingsaddles.com%2Fnew-york%2Fbikes-and-rates%2Fgovernors-island|||\" btn_size=\"ubtn-small\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"10227\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][vc_custom_heading text=\"Kajakken rondom Governor Island\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Naast fietsen is het ook mogelijk om actief te kajakken in de wateren rondom Governors Island. Vanaf midden juni tot midden september kun je gratis een kajak huren bij Downtown Boathouse. Hoe tof is het om te kajakken in de wateren rondom Manhattan en ondertussen het Vrijheidsbeeld op de achtergrond te spotten.</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"10230\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][vc_custom_heading text=\"Colonels Row\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Op Governors Island worden gedurende de zomer diverse evenementen georganiseerd. Vaak is Colonels Row de plek waar deze evenementen plaatsvinden. De statige lanen worden omringd door militaire gebouwen, huizen en grasvelden. Vergaap je aan de schoonheid van Governor Island.\u00a0</span>\r\n\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"10226\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][vc_custom_heading text=\"Castle Williams\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Een van de twee verdedigingswerken op Governors Island is Castle Williams. Vanaf het water zie je de rode bakstenen van Castle Williams al liggen. Het kasteel werd in 1811 gebouwd om de haven van New York te beschermen. In de afgelopen jaren deed het nog dienst als gevangenis, legerkazerne en opslagplek. Tegenwoordig is Castle Williams te bezoeken en daarbij krijg je informatie over de geschiedenis van het verdedigingswerk.</span>\r\n\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"10231\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][vc_custom_heading text=\"Hammock Cove\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Op Hammock Cove hangen vijftig iconische rode hangmatten. Op een tiental hectare waarop 1500 nieuwe bomen gezet zijn, kun je even bijkomen in deze hangmatten. En met een beetje geluk kijk je uit op Lady Liberty.</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"10229\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][vc_custom_heading text=\"Ligget Terrace\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Wanneer je naar Governors Island gaat, heb je niet heel veel mogelijkheden om iets te eten te scoren. Op Ligget Terrace zijn een aantal mogelijkheden tot het kopen van eten bij diverse foodtrucks. Overigens is Ligget Terrace een gezellige plek met leuke terrasjes en speelmogelijkheden voor de kinderen.</span>\r\n\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1640068412576{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Enjoy the view!\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][vc_custom_heading text=\"Uitzicht vanaf Governor Island\" font_container=\"tag:div|font_size:35|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"6972\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Algemene informatie Governor Island\" font_container=\"tag:div|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\"><strong>Eten en drinken</strong>\r\nDiverse foodtrucks staan op het eiland die eten verkopen als empanada\u2019s, burgers en ijs. Je mag natuurlijk je eigen eten en drinken meenemen om bijvoorbeeld te picknicken op de grasvelden.</span>\r\n\r\n<strong>Toiletten</strong>\r\nBij de aankomst van de ferry zijn er toiletten te vinden. Daarnaast zijn er op diverse locaties op het eiland ook toiletten. Op de plattegrond staan de overige toiletten te vinden.\r\n\r\n<strong>Hoe lang heb je nodig op het eiland?</strong>\r\nAls je wilt, kun je rustig een dag op het eiland blijven. Er is genoeg te doen en te zien. Een dagdeel is ook genoeg om kennis te maken met Governors Island.[/vc_column_text][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"1/2\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Op een zomerse dag door de weeks, is Governor Island echt een aanrader. Wandel over het eiland, ga zitten op een van de bankjes en het enige wat je hoeft te doen is genieten!\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:100%20light%20regular%3A100%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie\" font_container=\"tag:div|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<strong>Geopend</strong>: 1 mei \u2013 31 oktober \u2013 maandag t/m vrijdag 10.00-18.00, zaterdag &amp; zondag 10.00-19.00 uur\r\n<strong>Ferry</strong>: Battery Maritime Building / Voor de tijden <a href=\"https://www.govisland.com/visit-the-island/reopening-updates\" target=\"_blank\" rel=\"noopener noreferrer\">klik hier</a>.\r\n<strong>Prijs</strong>: $3\r\n<strong>Metro</strong>: Whitehall: R W / South Ferry: 1 / Bowling Green: 4 5\r\n<strong>Beste tijd om te bezoeken</strong>: Maandag, dinsdag en woensdag. In de weekenden is het vaak drukker en zijn er vaker festivals of evenementen[/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York\" font_container=\"tag:div|font_size:55|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:572,1759,667,1571\"][/vc_column][/vc_row]","post_title":"Governors Island","post_link":"https://www.heyusa.com/nl/governors-island-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Governor Island\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Governor-Island-boot-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1640068412576{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}","%_edit_last%":"1","%_edit_lock%":"1640169258:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"15","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":[{"title":"Foto credit: Julienne Schaer/NYC & Company","post_source_url":"http://www.nycgo.com"}],"%_thumbnail_id%":"6976","%_yoast_wpseo_focuskw%":"Governor Island in New York","%_yoast_wpseo_title%":"%%title%% in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een leuke bezienswaardigheid in New York is het eiland Governor Island. Tips voor je bezoek aan Governor Island in New York.","%_yoast_wpseo_linkdex%":"69","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"Governors Island, New York City, New York 11231, Verenigde Staten","%_wpgmp_location_city%":"New York City","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.68945009999999","%_wpgmp_metabox_longitude%":"-74.016792","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1677015549","taxonomy=category":"Bezienswaardigheden New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":1840,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Helikoptervlucht New York","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Helikopter New York\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Helikopter-ny-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Helikoptervlucht New York</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"Boottocht van 90 minuten over de Hudson en East River","address":"New York City, New York, Verenigde Staten","location":{"lat":"40.7127753","city":"New York City","state":"New York","country":"Verenigde Staten","lng":"-74.0059728","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/new-york-city/helikoptervluchten-new-york/","zoom":12,"extra_fields":{"post_excerpt":"Boottocht van 90 minuten over de Hudson en East River","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text][/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"25px\"][vc_custom_heading text=\"Helikoptervlucht New York - bekijk de stad vanuit de lucht\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Een ervaring die je niet snel gaat vergeten; een helikoptervlucht New York. Een magische en unieke ervaring die je waarschijnlijk een keer in je leven doet, want het klinkt niet alleen duur, het is ook vrij duur. Toch is het er een die je op je bucketlist moet zetten, want hoe gaaf is het om de skyline met het Empire State Building, One World Trade Center en de Brooklyn Bridge vanuit de lucht te zien!</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf \u20ac190 per persoon[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1640069307156{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Helikoptervlucht New York\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">Met een helikopter boven New York is een super gave ervaring. Sowieso stap je al niet zo snel in een helikopter, laat staan dat je boven de stad vliegt. Hoe gaaf is het om al die beroemde gebouwen vanuit de lucht te zien! Een piepklein Vrijheidsbeeld of wat dacht je van met de voeten boven het Empire State Building bungelen?\r\nIn Manhattan heb je vele aanbieders die een helikoptervlucht boven de stad aanbieden. Zo kun je vanaf de East River Piers verschillende opties proberen. De routes zijn vaak verschillend, net als het aantal minuten dat je in de helikopter zit.\r\n</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Welkom aan boord!\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Ontdek New York op een ultieme manier\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"1793\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Verschillende soorten helikoptervluchten in New York\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Met je voeten uit de helikopter, of juist veilig achter een deur\" font_container=\"tag:div|font_size:35|text_align:center|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"25px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"1793\" img_size=\"large\"][vc_custom_heading text=\"Helikoptervlucht zonder deuren in New York\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Hoewel een helikoptervlucht al een hele beleving is, kun je ervoor kiezen om te gaan vliegen met een <a href=\"https://www.getyourguide.com/new-york-city-l59/new-york-city-helicopter-tour-of-iconic-landmarks-t405780/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=heliflynyonintekst\" target=\"_blank\" rel=\"noopener\">helikopter zonder deuren</a>! Voor de avonturiers en fotografen de optie om een helikoptervlucht tot een onvergetelijke ervaring te maken. Hoe tof is het om met je benen buiten boord te bungelen met op de achtergrond de skyline van Manhattan?</span>[/vc_column_text][vc_column_text]<span style=\"font-weight: 400;\"><strong>Duur</strong>: 16 minuten\r\n<strong>Vertrekpunt</strong>: 78 John Miller Way, Kearny, NJ New Jersey\r\n<strong>Vertrektijden</strong>: variabel\r\n<strong>Tips</strong>: Zorg dat je er tenminste 30 minuten voor vertrek bent &amp; let op: er zijn geen vluchten meer op zondag. Hierdoor zijn de andere dagen sneller volgeboekt, dus wanneer mogelijk reserveer van te voren. Je kunt ook een shuttle bijboeken om in New Jersey te komen, scheelt weer stress.\r\n</span>\r\n\r\n[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fnew-york-city-helicopter-tour-of-iconic-landmarks-t405780%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dheliflynyon|title:Bestel%20helicopter%20tickets%20voor%20FlyNYOn|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"6940\" img_size=\"large\"][vc_custom_heading text=\"Helikoptervlucht boven Manhattan\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">In 12-15 minuten word je meegenomen tijdens een spannende <a href=\"https://www.getyourguide.com/new-york-city-l59/liberty-harbor-helicopter-adventure-t15252/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=helinyckortintekst\" target=\"_blank\" rel=\"noopener\">helikoptervlucht over Manhattan</a>. Vlieg langs het Vrijheidsbeeld, Wall Street en One World Trade Center en vang een glimp op van het Empire State Building. New York in vogelperspectief!\r\n</span>[/vc_column_text][vc_column_text]<span style=\"font-weight: 400;\"><strong>Duur: </strong>12-15 minuten<strong>\r\nVertrekpunt: </strong>Downtown Heliport op Pier 6<strong>\r\nVertrektijden: </strong>variabel<strong>\r\nTips: </strong>Zorg dat je er tenminste 30 minuten voor vertrek bent &amp; let op: er zijn geen vluchten meer op zondag. Hierdoor zijn de andere dagen sneller volgeboekt, dus wanneer mogelijk reserveer van te voren.<strong>\r\n</strong></span>\r\n\r\n[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fliberty-harbor-helicopter-adventure-t15252%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dhelinyckort|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"6941\" img_size=\"large\"][vc_custom_heading text=\"Helikoptervlucht over New York en Manhattan\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Wil je iets langer genieten van het mooie uitzicht, dan kun je ook met een vlucht mee van 15-30 minuten. Je betaalt hiervoor natuurlijk wel wat meer. Met <a href=\"https://www.getyourguide.com/new-york-city-l59/new-york-city-15-minute-helicopter-tour-t19901/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=helinyclangintekst\" target=\"_blank\" rel=\"noopener\">deze vlucht</a> ga je iets verder New York in dan die bij die van 15 minuten. Je krijgt hierdoor onder andere Central Park, Governor Island en het Vrijheidsbeeld via de Hudson River te zien. Een ideale manier om de skyline van New York te bekijken zonder drukte om je heen.\r\n</span>[/vc_column_text][vc_column_text]<span style=\"font-weight: 400;\"><strong>Duur: </strong>15-30 minuten<strong>\r\nVertrekpunt: </strong>Downtown Heliport op Pier 6<strong>\r\nVertrektijden: </strong>variabel<strong>\r\nTips:</strong> Zorg dat je er tenminste 30 minuten voor vertrek bent &amp; let op: er zijn geen vluchten meer op zondag. Hierdoor zijn de andere dagen sneller volgeboekt, dus wanneer mogelijk reserveer van te voren.<strong>\r\n</strong></span>[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fnew-york-city-15-minute-helicopter-tour-t19901%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dhelinyclang|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Enjoy the view!\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Uitzicht vanuit een helikopter zonder deuren in NYC\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fnew-york-city-helicopter-tour-of-iconic-landmarks-t405780%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dheyusa_website|title:Bestel%20helicopter%20tickets%20voor%20FlyNYOn|target:_blank\" btn_align=\"ubtn-center\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"1794\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Hoe gaat een helikoptervluchten in New York in zijn werk?\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Wanneer je met een helikoptervlucht meegaat, krijg je van te voren een duidelijke veiligheidsinstructie wat er gebeurd als je in nood bent. Zeker wanneer je meegaat met de helikopter zonder deuren, heb je van te voren een uitgebreide veiligheids-check. Je zit hier namelijk vast gesnoerd aan de helikopter. Ook alle losse spullen worden gecheckt en goed vastgezet. Een telefoon gaat vast op een stick en ook je camera moet om je nek. Na de veiligheidsinstructie is het tijd om naar de helikopters te gaan en tijd voor een unieke ervaring![/vc_column_text][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"1/2\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Tip voor een helikoptervlucht in New York:\" font_container=\"tag:h2|font_size:15|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Wil je de ultieme ervaring? Boek dan de uitgebreide variant van de helikoptervlucht zonder deuren. Die paar tientjes ben je over een tijd wel vergeten en het uitzicht over Central Park is echt fenomenaal boven in de lucht. Het is echt een van de mooiste ervaringen in New York!\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:100%20light%20regular%3A100%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/3\"][vc_single_image image=\"1790\" img_size=\"large\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York:\" font_container=\"tag:div|font_size:55|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"25px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"by_id:1571,1484,1559,1647\"][/vc_column][/vc_row]","post_title":"Helikoptervlucht New York","post_link":"https://www.heyusa.com/nl/new-york-city/helikoptervluchten-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Helikopter New York\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Helikopter-ny-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1640069307156{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}","%_edit_last%":"2","%_edit_lock%":"1711527746:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"15","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":"","%_thumbnail_id%":"1792","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Helikoptervlucht New York","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_metadesc%":"Op zoek naar een unieke ervaring in New York? Boek dan een helikoptervluchten in New York. Een helikoptervlucht New York is enorm gaaf.","%_yoast_wpseo_linkdex%":"75","%_wpgmp_location_address%":"New York City, New York, Verenigde Staten","%_wpgmp_location_city%":"New York City","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7127753","%_wpgmp_metabox_longitude%":"-74.0059728","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"4\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1680002120","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_primary_category%":"","taxonomy=category":"Bezienswaardigheden New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/stad.png"},"id":1784,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/stad.png","name":"New York City","id":"4","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Roosevelt Island Tram","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Roosevelt Island\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Roosevelt-Island-Tram-2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Roosevelt Island Tram</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"New York City, New York 10044, Verenigde Staten","location":{"lat":"40.7612521","city":"New York City","state":"New York","country":"Verenigde Staten","lng":"-73.9642344","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/new-york/roosevelt-island-tram/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Roosevelt Island Tram in New York\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Een leuke activiteit tijdens je stedentrip in <a href=\"https://www.heyusa.com/nl/new-york/\" target=\"_blank\" rel=\"noopener\">New York</a> is een ritje met de Roosevelt Island Tram, een kabelbaan over de East River naar <a href=\"https://www.heyusa.com/nl/roosevelt-island-new-york-city/\" target=\"_blank\" rel=\"noopener\">Roosevelt Island</a>. Officieel is deze activiteit niet helemaal gratis, maar de meesten hebben wel een Unlimited MetroCard tijdens hun bezoek aan New York. Met deze kaart kun je gebruik maken van de Roosevelt Island kabelbaan. Een spectaculair uitzicht tijdens een ritje over de East River die je niet mag missen tijdens je bezoek aan New York.</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Ritje Metrocard[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1613031556007{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Tips voor de de Roosevelt Island Tram in New York\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">Op 2nd Avenue en 60th Street vind je de ingang van de kabelbaan die je naar <a href=\"https://www.heyusa.com/nl/newyork/newyorkcity/parken/roosevelt-island/\" target=\"_blank\" rel=\"noopener noreferrer\">Roosevelt Island</a> brengt. Je kunt gewoon je MetroCard gebruiken om binnen te komen en in de gondel te stappen die er ongeveer vijf minuten over doet. De gondels gaan heen en weer, dus echt lang hoef je niet te wachten.\r\n</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Beleef New York zoals Spiderman\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Vlieg over daken, straten en de East River\" font_container=\"tag:div|font_size:40|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"1749\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Weetjes over de Roosevelt Island Tram\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Nadat je een unieke ervaring hebt gehad in de kabelbaan kun je natuurlijk direct weer terug naar Manhattan, maar je kunt ook even rondlopen op Roosevelt Island. Het is een klein eiland in de East River waar mensen wonen en werken. Volg de rivier en kijk uit over de skyline van Manhattan. Langs het pad staan vele bankjes voor een rustpauze. Aan het eind van het eiland vind je het Franklin D. Roosevelt Four Freedoms Park. Het eiland is ongeveer 3,2 kilometer lang en maar 240 meter breed.</span>\r\n\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Tips voor het nemen van de Roosevelt Island Tram\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Hoewel de Cable Cars relatief klein zijn, heb je vaak een 360 graden uitzicht over New York. Wil je richting Lower Manhattan kijken? Zorg dan dat je bij instap vanaf Manhattan aan de rechterkant plaatsneemt, hier kijk je letterlijk door de straten naar het zuiden van Manhattan. Een mooi tijdstip om Roosevelt Island te bezoeken is tijdens zonsopkomst. De zon schijnt op de gebouwen in Manhattan waardoor deze van goud lijken.\r\n</span>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Enjoy the view!\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Het uitzicht vanaf Roosevelt Island\" font_container=\"tag:h3|font_size:35|text_align:center|color:%23ffffff|line_height:3\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"1753\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York:\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:1759,1875,1784,1571\"][/vc_column][/vc_row]","post_title":"Roosevelt Island Tram","post_link":"https://www.heyusa.com/nl/new-york/roosevelt-island-tram/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Roosevelt Island\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Roosevelt-Island-Tram-2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1613031556007{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"1","%_edit_lock%":"1664989056:1","%_wpb_vc_js_status%":"true","%post-primary-category%":"14","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":[{"title":"Foto credit Roosevelt Island Tram: Julienne Schaer/NYC & Company","post_source_url":"http://www.nycgo.com"},{"title":"Foto credit Roosevelt Island Tram: Tagger Yancey IV/NYC & Company","post_source_url":"nycgo.com"}],"%_thumbnail_id%":"1748","%_yoast_wpseo_focuskw%":"Roosevelt Island Tram in New York","%_yoast_wpseo_title%":"%%title%% in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Op zoek naar een toffe ervaring in New York? Pak dan de Roosevelt Island Tram in New York en maak een ritje tussen de wolkenkrabbers van NYC.","%_yoast_wpseo_linkdex%":"72","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"New York City, New York 10044, Verenigde Staten","%_wpgmp_location_city%":"New York City","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7612521","%_wpgmp_metabox_longitude%":"-73.9642344","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_indexnow_last_ping%":"1677015556","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Bezienswaardigheden New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":1747,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Ellis Island Museum","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Ellis Island Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Ellis-Island-Museum1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Ellis Island Museum</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Ellis Island Bridge, Jersey City, NJ 10280, Verenigde Staten","location":{"lat":"40.6992753","city":"Jersey City","state":"New Jersey","country":"Verenigde Staten","lng":"-74.0394328","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/ellis-island-museum-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text]<strong>In het Ellis Island Museum in New York kom je alles te weten over de immigranten die naar Amerika afreisden om hun American Dream te gaan leven. Sinds 1892 moesten immigranten die zich wilden vestigen in Amerika via Ellis Island. Daarvoor was Castle Clinton in <a href=\"https://www.heyusa.com/nl/new-york/battery-park/\" target=\"_blank\" rel=\"noopener noreferrer\">Battery Park</a> de plek waar immigranten aan wal kwamen. Tegenwoordig vind je op Ellis Island een museum met diverse tentoonstellingen en interactieve media over de immigranten die via Ellis Island Amerika binnen kwamen.</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Lower Manhattan | Battery Park (start boottocht)\"][thb_iconlist icon=\"fas fa-subway\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Bowling Green | 4 | 5\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fstatue-of-liberty-ellis-island-ticket-options-with-ferry-t393246%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dellisislandmuseum\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ellis Island - lange tijd de eerste stop in Amerika\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Na het zien van het Vrijheidsbeeld was Ellis Island lange tijd de eerste echte plek waar vele immigranten kennis maakten met Amerika. Beleef de verhalen van deze immigranten en de geschiedenis van Ellis Island.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Toegangshal op Ellis Island\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Vol met verhalen van immigranten\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"3403\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"In het Ellis Island Museum\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"World Migration Globe\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Op deze gigantische wereldbol kun je de migratiepatronen van over de hele wereld door de jaren heen terugvinden. Leer over de verschillende immigratiepatronen die er hebben plaatsgevonden.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Journey: The people of America 1550s -1890\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In Ellis Island vind je deze tentoonstelling die gewijd is aan de allereerste mensen die arriveerden op Ellis Island. In verschillende galerijen worden diverse fases van immigrantenreizen in deze periode weergegeven.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Journey: New Era of Immigration\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Deze tentoonstelling in het museum richt zich op de immigratie vanaf 1954 tot heden. Door middel van media en interactieve elementen worden naoorlogse immigratiebewegingen en veranderende demografische trends van de afgelopen decennia weergegeven.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Ontdek de vroege verhalen van immigranten\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Wie weet kom je nog verre familieleden tegen op de lijst\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"3508\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ook leuk in New York City:\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][fullwidth_row][thb_postgrid columns=\"4\" source=\"post_type:post|by_id:1594,1312,408,1559\"][/vc_column][/vc_row]","post_title":"Ellis Island Museum","post_link":"https://www.heyusa.com/nl/ellis-island-museum-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Ellis Island Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/Ellis-Island-Museum1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1667989326:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"16","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Ellis Island Museum in New York","%_yoast_wpseo_title%":"%%title%% in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Het Ellis Island Museum in New York laat je kennis maken met de eerste aankomst van immigranten. Tips voor je bezoek aan het Ellis Island Museum.","%_yoast_wpseo_linkdex%":"67","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"Ellis Island Bridge, Jersey City, NJ 10280, Verenigde Staten","%_wpgmp_location_city%":"Jersey City","%_wpgmp_location_state%":"New Jersey","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.6992753","%_wpgmp_metabox_longitude%":"-74.0394328","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"3507","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1677015557","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Musea New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":1619,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Pak de gratis Staten Island Ferry in New York","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Staten Island Ferry met het Vrijheidsbeeld op de achtergrond\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/staten-island-ferry-4-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Pak de gratis Staten Island Ferry in New York</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Staten Island Ferry, Staten Island, NY, Verenigde Staten","location":{"lat":"40.6468667","state":"New York","country":"Verenigde Staten","lng":"-74.0683612","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/new-york/staten-island-ferry/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"25px\"][ultimate_heading main_heading=\"Staten Island Ferry in New York\" main_heading_color=\"#b34a4c\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:50px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Vaar gratis langs het Vrijheidsbeeld\" font_size=\"50\" line_height=\"50\" font_color=\"#282828\"][vc_column_text]<span style=\"font-weight: 400;\">De Staten Island Ferry in New York is de ferry die tussen de boroughs Manhattan en <a href=\"https://www.heyusa.com/nl/wat-te-doen-in-staten-island-new-york/\">Staten Island</a> vaart in New York. Doordat de ferry <a href=\"https://www.heyusa.com/nl/governors-island-new-york/\">Governor Island</a>, het <a href=\"https://www.heyusa.com/nl/vrijheidsbeeld-ellis-island-new-york/\">Vrijheidsbeeld</a> en Ellis Island passeert, is het ook nog eens een leuke manier om het Vrijheidsbeeld van dicht bij te aanschouwen. De ferry vertrekt vanaf het zuidelijke puntje vanaf Manhattan bij de Whitehall Terminal en vaart 24 uur per dag, 7 dagen per week. Het leuke van de ferry? Hij is helemaal gratis! Daarom is de Staten Island Ferry een leuke <a href=\"https://www.heyusa.com/nl/tips-gratis-activiteiten-new-york/\">gratis activiteit in New York</a>.\r\n</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Gratis[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612950540814{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Een aantal tips voor de gratis Staten Island Ferry\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<ul>\r\n \t<li style=\"text-align: left;\">De ferry vertrekt vanaf Whitehall Ferry Terminal en de beste metrohalte om uit te stappen is South Ferry. Deze kun je bereiken met lijn 1 of R.</li>\r\n \t<li style=\"text-align: left;\">In de terminal vind je een wachtruimte met redelijk wat voorzieningen. Er zijn toiletten, een kiosk voor snacks en er is wifi.</li>\r\n \t<li style=\"text-align: left;\">De Staten Island Ferry vertrekt in de spits tussen de 15 en 20 minuten, op andere tijden van de dag tussen de 30 en 60 minuten. Lang hoef je dus niet te wachten in de terminal.</li>\r\n \t<li>Het tochtje is ongeveer 25 minuten</li>\r\n \t<li style=\"text-align: left;\">Bekijk hier het <a style=\"text-align: center;\" href=\"https://www.siferry.com/schedules.html\" target=\"_blank\" rel=\"noopener noreferrer\">vaarschema van de Staten Island Ferry</a></li>\r\n</ul>\r\n[/vc_column_text][thb_iconbox type=\"left type1\" animation=\"\" icon_image=\"19694\" icon_image_width=\"125\" heading=\"New York expert tip van Marjolein:\" description=\"Geen tijd om Staten Island te verkennen? Je moet even uitstappen, maar je kunt direct de ferry weer terugpakken naar Manhattan.\" thb_heading_color=\"#b34a4c\" thb_text_color=\"#282828\" heading_font_size=\"17px\" description_font_size=\"16px\"][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Leuke gratis activiteit in New York\" font_size=\"55\" line_height=\"60\" font_color=\"#ffffff\"][vc_custom_heading text=\"Bekijk het Vrijheidsbeeld van dichtbij\" font_container=\"tag:h3|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"5378\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Weetjes over de Staten Island Ferry\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">De eerste ferry tussen Staten Island en Manhattan ging in 1817. De ferry was niet altijd gratis, pas sinds 1997 hoef je niets meer te betalen voor de overtocht. De ferry zelf is enorm groot en vervoert dagelijks bijna 70.000 passagiers tijdens de 104 afvaarten. Ook op de ferry zelf zijn voldoende faciliteiten te vinden. Aan boord heb je de mogelijkheid tot eten en drinken en er is een toilet aanwezig. Hoewel het eigenlijk bedoelt is als vervoersmiddel voor de inwoners van Staten Island, reizen ook veel toeristen graag mee op de ferry.\r\n</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Tips voor het beste uitzicht op de Ferry\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Voor de beste uitzichten kun je het beste op de achterkant van de ferry blijven. Hier heb je uitzichten over de skyline van Manhattan en het Vrijheidsbeeld. De ferry is een leuke manier om dichter bij het Vrijheidsbeeld te komen, zonder daar kosten voor hoeven te maken. Een leuke activiteit die gratis is tijdens een dure stedentrip in New York is altijd fijn!\r\n</span>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1678194198432{padding-top: 100px !important;padding-bottom: 100px !important;background-color: #ffffff !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"100%\"][vc_row_inner content_placement=\"middle\"][vc_column_inner width=\"1/2\"][vc_single_image image=\"15148\" img_size=\"large\" onclick=\"custom_link\" img_link_target=\"_blank\" link=\"Oekra\u00efne\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Op zoek naar nog meer onbekende plekken in New York?\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:300%20light%20regular%3A300%3Anormal\"][vc_custom_heading text=\"Check dan onze reisgidsen over New York &amp; Brooklyn\" font_container=\"tag:div|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"15px\"][vc_column_text]Klaar om te vertrekken? Ontdek New York en Brooklyn als een \u00e9chte New Yorker met onze unieke reisgidsen![/vc_column_text][thb_button link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fwebshop%2Fhallo-reisgidsen%2F|title:Bestel%20een%20reisgids\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Enjoy the view!\" font_size=\"55\" line_height=\"60\" font_color=\"#ffffff\"][vc_custom_heading text=\"Het uitzicht vanaf de ferry\" font_container=\"tag:h3|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"1737\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:1571,968,910,1784\"][/vc_column][/vc_row]","post_title":"Pak de gratis Staten Island Ferry in New York","post_link":"https://www.heyusa.com/nl/new-york/staten-island-ferry/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Staten Island Ferry met het Vrijheidsbeeld op de achtergrond\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/09/staten-island-ferry-4-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1612950540814{background-color: #ededed !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1678194198432{padding-top: 100px !important;padding-bottom: 100px !important;background-color: #ffffff !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_edit_last%":"2","%_edit_lock%":"1716793029:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"14","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":[{"title":"Foto credit Staten Island Ferry: Julienne Schaer/NYC & Company","post_source_url":"http://www.nycgo.com"},{"title":"Foto credit Staten Island Ferry: Matthew Penrod/NYC & Company","post_source_url":"nycgo.com"},{"title":"Foto credit Staten Island Ferry: Jen Davis/NYC & Company","post_source_url":"nycgo.com"}],"%_thumbnail_id%":"19988","%_yoast_wpseo_focuskw%":"Staten Island Ferry New York","%_yoast_wpseo_title%":"%%title%% in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"De Staten Island Ferry in New York is een leuke manier om het Vrijheidsbeeld van dicht bij te bekijken en ook nog eens gratis! Een aantal tips","%_yoast_wpseo_linkdex%":"77","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Staten Island Ferry\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"Staten Island Ferry, Staten Island, NY, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.6468667","%_wpgmp_metabox_longitude%":"-74.0683612","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1716792238","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_wordproof_timestamp%":"","%_jetpack_memberships_contains_paid_content%":"","%activeer_submenu%":"1","%_activeer_submenu%":"field_6593f521e97c2","%locatie_submenu%":"Selecteer een pagina","%_locatie_submenu%":"field_6593f531e97c3","%selecteer_pagina%":"18453","%_selecteer_pagina%":"field_6593f8be019da","%_yoast_wpseo_primary_category%":"","taxonomy=category":"Bezienswaardigheden New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":1733,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Statue of Liberty Museum","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Statue of Liberty Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/statue-of-liberty-museum-nyc-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Statue of Liberty Museum</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Liberty Island - Ellis Island, New York, NY 10004, Verenigde Staten","location":{"lat":"40.69095","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-74.04606009999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/statue-of-liberty-museum-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text]<strong>Met ruim 26.000 vierkante meter is het Statue of Liberty Museum de plek om mensen te informeren over de geschiedenis van het Vrijheidsbeeld. In het museum bevinden zich drie verschillende galerieruimtes die ieder verschillende kanten van het verhaal belichten. Naast alle informatie over de geschiedenis van het Vrijheidsbeeld, kun je deze natuurlijk ook beklimmen. Niet alleen een fantastische ervaring, maar ook nog eens een fenomenaal uitzicht over Manhattan.</strong>\r\n\r\n[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Lower Manhattan | Battery Park (start boottocht)\"][thb_iconlist icon=\"fas fa-subway\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Bowling Green | 4 | 5\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.viator.com%2Ftours%2FNew-York-City%2FStatue-of-Liberty-Express-Optional-Pedestal%2Fd687-15081P220%3Fpid%3DP00074479%26mcid%3D42383%26medium%3Dlink%26campaign%3Dstatueoflibertymuseum\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Start van de American Dream\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Het Vrijheidsbeeld staat voor velen gelijk aan het uitkomen van de American Dream. Leer meer over het Vrijheidsbeeld en beklim het symbool van Amerika. Vertrek met de ferry vanaf <a href=\"https://www.heyusa.com/nl/new-york/battery-park/\" target=\"_blank\" rel=\"noopener noreferrer\">Battery Park</a> en ontdek alles over Lady Liberty in het Statue of Liberty Museum.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Ontdek het Statue of Liberty Museum\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Combineer het Vrijheidsbeeld met het Statue of Liberty Museum\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"10649\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"In het Statue of Liberty Museum\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Walkthrough Theatre\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In het theater word je ondergedompeld in de oprichting en constructie van het Vrijheidsbeeld. Je kunt zelfs een filmische rondvlucht krijgen door het standbeeld zelf.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Engagement Gallery\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In de Engagement Gallery kun je zien hoe het Vrijheidsbeeld is opgebouwd. Door middel van interactieve programma\u2019s leer je over de symbolische manier van het Vrijheidsbeeld.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Inspiration Gallery\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Hierin word je uitgedaagd om een zelfportret en een collage van foto\u2019s te delen zodat het moza\u00efek met alle bezoekers steeds veranderd en hierdoor een collectieve kijk op vrijheid weerspiegelt.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Bekijk de constructie van het Vrijheidsbeeld\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Dompel je onder in de oprichting van het Vrijheidsbeeld\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"10650\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ook leuk in New York City:\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][fullwidth_row][thb_postgrid columns=\"4\" source=\"post_type:post|by_id:1594,1312,408,1559\"][/vc_column][/vc_row]","post_title":"Statue of Liberty Museum","post_link":"https://www.heyusa.com/nl/statue-of-liberty-museum-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Statue of Liberty Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/statue-of-liberty-museum-nyc-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1667988946:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"16","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Statue of Liberty Museum","%_yoast_wpseo_title%":"%%title%% in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Het Statue of Liberty Museum verteld je alles over het Vrijheidsbeeld. Tips voor je bezoek aan het Statue of Liberty Museum in New York.","%_yoast_wpseo_linkdex%":"74","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"Liberty Island - Ellis Island, New York, NY 10004, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.69095","%_wpgmp_metabox_longitude%":"-74.04606009999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_thumbnail_id%":"10651","%_yoast_indexnow_last_ping%":"1677015520","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Musea New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":1616,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Brooklyn Museum","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Brooklyn Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/Brooklyn-Museum1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Brooklyn Museum</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"200 Eastern Pkwy, Brooklyn, NY 11238, Verenigde Staten","location":{"lat":"40.6712062","state":"New York","country":"Verenigde Staten","lng":"-73.9636306","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/brooklyn-museum-new-york-city/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Het Brooklyn Museum\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]<strong>Het Brooklyn Museum is een van de grootste musea in de Verenigde Staten en de op een na grootste van New York. In de permanente collectie zijn ongeveer anderhalf miljoen voorwerpen te vinden. Het museum staat midden in Brooklyn en je bent ongeveer een half uur onderweg vanaf Midtown Manhattan. Het omvat een grote diversiteit aan meesterwerken en kunst van vele culturen. Verlaat Manhattan eens om dit prachtige museum te bezoeken.</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Brooklyn | 200 Eastern Parkway\"][thb_iconlist icon=\"fas fa-subway\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Eastern Parkway | 2 | 3\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"BOEK JE TICKETS\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fnew-york-brooklyn-museum-ticket-with-exhibit-upgrades-t413698%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dbrooklynmuseum|title:Brooklyn%20Museum%20Tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Het een na grootste museum van New York\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In het enorme Brooklyn Museum komen liefhebbers van kunst aan hun trekken. Bekijk de enorme hoeveelheid kunstwerken van over de hele wereld. Bezoek eens een minder bekend museum tijdens je stedentrip in New York en ontdek tegelijkertijd verschillende wijken in Brooklyn en het nabijgelegen <a href=\"https://www.heyusa.com/nl/prospect-park-new-york/\" target=\"_blank\" rel=\"noopener\">Prospect Park</a>!</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Walhalla voor de kunstliefhebbers\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Een collectie van meer dan 1.5 miljoen stukken\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"1608\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Wat mag je niet missen in het Brooklyn Museum\" font_container=\"tag:h2|font_size:50|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/4\"][vc_single_image image=\"7366\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Oude Egyptische kunst\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]De collectie oude Egyptische kunst in het Brooklyn Museum is een van de grootste en mooiste in de Verenigde Staten. Je vindt hier kunstwerken die het verhaal vertellen van de Egyptenaren na de Romeinse tijd. Meer dan 1200 voorwerpen, waaronder beeldhouwwerken, reli\u00ebf, schilderijen en aardewerk, laten deze geschiedenis van de oude Egyptenaren zien. Vergeet ook niet om de mummie-kamer te bezoeken tijdens je bezoek aan het Brooklyn Museum.\r\n\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][vc_single_image image=\"7368\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Sculpture Garden\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]In de Steinberg Family Sculpture Garden vind je een aparte verzameling objecten. Hier liggen namelijk objecten die gered zijn van slooplocaties in New York. Een opmerkelijke collectie, want het zijn grotendeels sculpturen van anonieme ambachtslieden. De collectie laat voorbeelden zien van objecten die gebruikt werden om huizen en commerci\u00eble gebouwen te versieren.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][vc_single_image image=\"7369\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"American Art\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]De collectie Amerikaanse kunst in het Brooklyn Museum omvat verschillende tijdsperiodes en thema\u2019s. Een breed scala van media, meubels, schilderijen, beeldhouwwerken en keramiek laten de veranderingen zien in de Amerikaanse kunst sinds 4000 voor Christus. De collectie is uitgebreid naar ook Midden en Zuid-Amerika, Mexico en het Caribische gebied.\r\n\r\n[/vc_column_text][/vc_column_inner][vc_column_inner thb_color=\"thb-light-column\" width=\"1/4\" css=\".vc_custom_1625324880871{padding-top: 25px !important;padding-right: 25px !important;padding-bottom: 25px !important;padding-left: 25px !important;background-color: #b34a4c !important;}\"][vc_widget_sidebar sidebar_id=\"ca-sidebar-5228\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Prospect Park\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Het 'Central Park' van Brooklyn\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fnewyork%2Fnewyorkcity%2Fparken%2Fthe-high-line%2F|title:The%20High%20Line\" btn_align=\"ubtn-center\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"7374\"][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"Brooklyn Museum","post_link":"https://www.heyusa.com/nl/brooklyn-museum-new-york-city/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Brooklyn Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/Brooklyn-Museum1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}.vc_custom_1625324880871{padding-top: 25px !important;padding-right: 25px !important;padding-bottom: 25px !important;padding-left: 25px !important;background-color: #b34a4c !important;}","%_edit_lock%":"1717665301:2","%_edit_last%":"2","%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%_thumbnail_id%":"1609","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Brooklyn Museum","%_yoast_wpseo_title%":"%%title%% in New York%%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Het Brooklyn Museum in New York is een prachtig museum vol kunstwerken. Tips voor je bezoek aan het Brooklyn Museum in Brooklyn.","%_yoast_wpseo_linkdex%":"77","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"200 Eastern Pkwy, Brooklyn, NY 11238, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.6712062","%_wpgmp_metabox_longitude%":"-73.9636306","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1717665428","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","%_jetpack_memberships_contains_paid_content%":"","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","%_yoast_wpseo_primary_category%":"","taxonomy=category":"Musea New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":1606,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Whitney Museum of American Art","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Whitney Museum of Art\" width=\"300\" height=\"208\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/whitney-museum-of-art-300x208.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Whitney Museum of American Art</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"99 Gansevoort St, New York, NY 10014, Verenigde Staten","location":{"lat":"40.73958770000001","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-74.0088629","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/whitney-museum-of-american-art-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text]<strong>Het Whitney Museum of American Art, kortweg Whitney, is minder bekend dan het MoMA en het Guggenheim in New York. Beiden hebben een grote collectie moderne kunst. Toch is ook het Whitney museum erg interessant voor liefhebbers van de moderne kunst. Vernoemd naar en opgericht door socialite Gertrude Vanderbilt Whitney, werd het museum opgericht in 1930. Inmiddels is het museum al vier keer verhuisd vanwege de collectie die steeds groter werd en tegenwoordig is het museum te vinden in het <a href=\"https://www.heyusa.com/nl/newyork/newyorkcity/buurten/meatpacking-district/\" target=\"_blank\" rel=\"noopener noreferrer\">Meatpacking District</a>. Het begon destijds als platform voor Amerikaanse kunstenaars die moeite hadden met het vinden van een expositieplek en inmiddels is het een gerenommeerd museum. In het huidige museum zijn zo\u2019n 22.000 werken te vinden uit de Amerikaanse kunst in de twintigste eeuw.</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Meatpacking District | 99 Gansevoort Street\"][thb_iconlist icon=\"fas fa-subway\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"14th Street &amp; 8th Avenue | A | C | E\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"BOEK JE TICKETS\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fthe-whitney-museum-of-american-art-t55485%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dwhitneymuseum|title:Whitney%20Museum%20Tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Museum voor liefhebbers van Amerikaanse kunst\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Het Whitney Museum of American Art is de plek voor liefhebbers van Amerikaanse kunst. Wat begon als een klein museum is uitgegroeid tot een enorm museum boordevol kunstwerken.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Whitney Museum aan de High Line\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Ideaal om te combineren met een wandeling\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"BOEK JE TICKETS\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fthe-whitney-museum-of-american-art-t55485%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dheyusa_website|title:Whitney%20Museum%20Tickets|target:_blank\" btn_align=\"ubtn-center\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"3503\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"In het Whitney Museum\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Museum en rooftop\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Sinds 2015 is Meatpacking een museum rijker; namelijk het Whitney Museum of American Art. De Italiaanse architect Renzo Piano ontwierp een museum van glas en blinkend staal. Daarmee is het museum op zich al een bezienswaardigheid geworden. Het gebouw telt negen verdiepingen en is een must voor allerlei soorten bezoekers. Het leuke aan het nieuwe gebouw is de mogelijkheid om bij verschillende lofts rondom het museum naar binnen te kijken. Via een trap buitenom ga je naar de volgende verdieping en daardoor kun je naar binnen kijken bij New Yorkers of richting de bootjes op de Hudson River.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"De vaste collectie van het Whitney\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Op de eerste twee verdieping is de vaste collectie te vinden van het museum. Hier krijg je een goede indruk van de hedendaagse Amerikaanse kunst. Kunstwerken van Willem de Kooning, Edward Hopper en Jasper Johns zijn hier te bewonderen. Niet alleen schilderijen behoren tot deze collectie, ook verrassende sculpturen zijn te bekijken. Via de vaste collectie van het Whitney Museum maak je kennis met het verhaal van de groei van het modernisme in Amerika.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Whitney Biennial\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Naast de vaste collectie staat het Whitney Museum bekend om een belangrijk event: Whitney Biennial. Het evenement wordt iedere twee jaar georganiseerd en staat in teken van de nieuwste kunst. In de tentoonstelling kun je de belangrijkste en relevantste kunstwerken bekijken van de afgelopen tijd. Hierbij gaat het niet alleen om schilderijen, maar onder andere ook sculpturen, film en video en fotografie.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"250px\"][ultimate_heading main_heading=\"THE HIGH LINE\" heading_tag=\"p\" main_heading_color=\"#ffffff\" sub_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:45px;\" sub_heading_font_family=\"font_family:Rubik Mono One|font_call:Rubik+Mono+One\" sub_heading_font_size=\"desktop:20px;\" main_heading_style=\"font-style:italic;font-weight:700;\"]8 meter boven de grond op een oude spoorweg[/ultimate_heading][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fnewyork%2Fnewyorkcity%2Fparken%2Fthe-high-line%2F|title:The%20High%20Line\" btn_align=\"ubtn-center\" btn_size=\"ubtn-small\" btn_bg_color=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_shadow=\"shd-bottom\" btn_shadow_color=\"#0a0a0a\" btn_shadow_size=\"5\" btn_font_family=\"font_family:Rubik Mono One|font_call:Rubik+Mono+One\" btn_font_size=\"desktop:18px;\"][vc_empty_space height=\"250px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"86\"][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"Whitney Museum of American Art","post_link":"https://www.heyusa.com/nl/whitney-museum-of-american-art-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Whitney Museum of Art\" width=\"300\" height=\"208\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/whitney-museum-of-art-300x208.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1717665304:2","%_edit_last%":"2","%_wpb_vc_js_status%":"true","%post-primary-category%":"16","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Whitney Museum of American Art","%_yoast_wpseo_title%":"%%title%% in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Het Whitney Museum of American Art is de plek voor Amerikaanse kunstenaars. Tips voor je bezoek aan het Whitney Museum of American Art.","%_yoast_wpseo_linkdex%":"81","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"99 Gansevoort St, New York, NY 10014, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.73958770000001","%_wpgmp_metabox_longitude%":"-74.0088629","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1717665413","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","%_thumbnail_id%":"20057","%_jetpack_memberships_contains_paid_content%":"","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","%_yoast_wpseo_primary_category%":"","taxonomy=category":"Musea New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":1603,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Tenement Museum","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Tenement Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/tenement-museum-les-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Tenement Museum</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"103 Orchard St, New York, NY 10002, Verenigde Staten","location":{"lat":"40.7188154","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.9901187","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/tenement-museum-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text]<strong>In de Lower East Side vind je het Tenement Museum. Zoals de naam al zegt, woonden er tussen 1863 en 2011 meer dan 15.000 mensen van verschillende afkomst in deze woningen. Het museum wil dan ook laten zien hoe de mensen leefden die destijds als die hun American Dream kwamen naleven in New York. Je ziet in het Tenement Museum in New York voorbeelden van hoe mensen in die periode leefden.</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Lower East Side | 103 Orchard Street\"][thb_iconlist icon=\"fas fa-subway\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Grand Street | B | D\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.tenement.org%2F\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Waan je in de geschiedenis van New York\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Beleef hoe de inwoners van New York leefden toen ze hun American Dream kwamen najagen vanaf 1863. Huizen overvol immigranten die probeerden hun dromen na te leven. Het Tenement Museum in New York laat je zien hoe de vroegere inwoners leefden in de <a href=\"https://www.heyusa.com/nl/newyork/newyorkcity/buurten/lower-east-side/\" target=\"_blank\" rel=\"noopener noreferrer\">Lower East Side</a>.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Ontdek de geheimen van het vroegere Lower East Side\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Waan je in het vroegere New York\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"10626\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"In het Tenement Museum\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Under one roof\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In deze tentoonstelling wordt stil gestaan bij het immigratieverhaal van nieuwkomers die zich na de Tweede Wereldoorlog in de Lower East Side vestigden. Je kunt hierbij de huizen bezoeken van Bella Epstein die na de Holocaust naar New York kwam of het huis van Jose en Andy Velez wiens moeder Puerto Rico verliet voor kleding. Ook het huis van de Wong broers en zussen en hun verhaal over de kledingwinkel die zij in Chinatown startten. Maak kennis met de inwoners van de Lower East Side.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Tour door de appartementen\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Met deze tour ga je door de appartementen van de vorige bewoners. Hierbij lijkt het alsof de tijd stil heeft gestaan, je loopt door woonkamers van meer dan een eeuw geleden. De gids verteld je hoe het leven was destijds en waar de mensen mee te maken kregen.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Neighborhood Walking Tour\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Een van de tours die georganiseerd wordt door het museum gaat door de buurt de Lower East Side. Hierbij worden diverse aspecten van de buurt uitgelicht. Zo wordt bijvoorbeeld verteld hoe de locals honderd jaar geleden hun tijd besteden. En natuurlijk wordt er in gegaan op de veranderingen die er in de wijk plaats hebben gevonden.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"250px\"][ultimate_heading main_heading=\"THE HIGH LINE\" heading_tag=\"p\" main_heading_color=\"#ffffff\" sub_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Arvo|font_call:Arvo|variant:700italic\" main_heading_line_height=\"desktop:45px;\" sub_heading_font_family=\"font_family:Rubik Mono One|font_call:Rubik+Mono+One\" sub_heading_font_size=\"desktop:20px;\" main_heading_style=\"font-style:italic;font-weight:700;\"]8 meter boven de grond op een oude spoorweg[/ultimate_heading][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fnewyork%2Fnewyorkcity%2Fparken%2Fthe-high-line%2F|title:The%20High%20Line\" btn_align=\"ubtn-center\" btn_size=\"ubtn-small\" btn_bg_color=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_shadow=\"shd-bottom\" btn_shadow_color=\"#0a0a0a\" btn_shadow_size=\"5\" btn_font_family=\"font_family:Rubik Mono One|font_call:Rubik+Mono+One\" btn_font_size=\"desktop:18px;\"][vc_empty_space height=\"250px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"86\"][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"Tenement Museum","post_link":"https://www.heyusa.com/nl/tenement-museum-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Tenement Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/tenement-museum-les-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1667988785:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"16","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Tenement Museum in New York","%_yoast_wpseo_title%":"%%title%% in New York%%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Het Tenement Museum in New York laat je de geschiedenis van de vroegere inwoners zien. Tips voor je bezoek aan het Tenement Museum.","%_yoast_wpseo_linkdex%":"72","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"103 Orchard St, New York, NY 10002, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7188154","%_wpgmp_metabox_longitude%":"-73.9901187","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_thumbnail_id%":"10627","%_yoast_indexnow_last_ping%":"1677015526","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Musea New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":1596,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Intrepid Sea, Air and Space Museum","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Intrepid Sea air and space museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/Intrepid-Sea-air-and-space-museum-2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Intrepid Sea, Air and Space Museum</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Pier 86, W 46th St, New York, NY 10036, Verenigde Staten","location":{"lat":"40.7645266","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.99960759999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/intrepid-sea-air-space-museum-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text]<strong>Zoals de naam al doet vermoeden, vind je in het Intrepid Sea, Air and Space Museum, de belangrijkste attributen uit de Amerikaanse geschiedenis van de zee-, lucht- en de ruimtevaart. Het museum is zelfs gevestigd op voormalig vliegdekschip USS Intrepid. Het schip was in de Tweede Wereldoorlog actief tegen de Japanners in de Stille Oceaan en doet nu dienst als bron voor zee-, lucht- en ruimtevaart geschiedenis. De USS Intrepid ligt in de Hudson rivier en is op zichzelf al een bezoek waard.</strong>\r\n\r\n[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Midtown Manhattan | Pier 86 - 46th Street\"][thb_iconlist icon=\"fas fa-subway\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"50 Street Subway | A | C | E\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fintrepid-sea-air-space-museum-tickets-t47360%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dintrepidseaairspace\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Indrukwekkend museum op een oud vliegdekschip\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Een enorm gevaarte zie je liggen wanneer je de wateren van de Hudson River nadert. Wat een prachtige manier om meer te weten te komen over de zee-, lucht- en ruimtevaart.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Walhalla voor de vliegtuigliefhebbers\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Een ruime collectie met indrukwekkende vliegtuigen\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"3497\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Wat mag je niet missen in het Intrepid Sea, Air and Space Museum\" font_container=\"tag:h2|font_size:50|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/4\"][vc_single_image image=\"3494\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Space Shuttle Paviljoen\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Naast de zee- en de luchtvaart neemt de ruimtevaart een belangrijke plek in de Amerikaanse geschiedenis. In het museum staat de space shuttle de Enterprise, een prototype van de NASA voor het space shuttle programma. De naam van de space shuttle komt uit de film Star Trek. Enterprise is nooit de ruimte ingegaan, maar werd gebruikt als prototype voor het testen voor onder andere de landing van een space shuttle.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][vc_single_image image=\"3493\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"British Airways Concorde\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Bezoek het snelste vliegtuig ter wereld in het Intrepid Museum. De British Airways Concorde heeft een wereldsnelheidsrecord voor passagiersvliegtuigen. Hij vloog op 7 februari 1996 van New York naar Londen in slechts 2 uur, 52 minuten en 59 seconden. Met 23397 vlieguren telt het de meeste vlieguren van alle concordes.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][vc_single_image image=\"3495\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Onderzee\u00ebr Growler\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Wanneer je geen last hebt van claustrofobie, kun je een kijkje nemen in de Growler. De onderzee\u00ebr Growler is de enige mogelijkheid om binnen in een Amerikaanse onderzee\u00ebr te kijken. Het staat sinds 1989 in het museum en geeft een goed beeld van het leven in de onderzee\u00ebr. Je kunt het grootste deel van de onderzee\u00ebr bekijken tijdens een bezoek aan het museum.[/vc_column_text][/vc_column_inner][vc_column_inner thb_color=\"thb-light-column\" width=\"1/4\" css=\".vc_custom_1625324880871{padding-top: 25px !important;padding-right: 25px !important;padding-bottom: 25px !important;padding-left: 25px !important;background-color: #b34a4c !important;}\"][vc_widget_sidebar sidebar_id=\"ca-sidebar-5228\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"250px\"][ultimate_heading main_heading=\"THE HIGH LINE\" heading_tag=\"p\" main_heading_color=\"#ffffff\" sub_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Arvo|font_call:Arvo|variant:700italic\" main_heading_line_height=\"desktop:45px;\" sub_heading_font_family=\"font_family:Rubik Mono One|font_call:Rubik+Mono+One\" sub_heading_font_size=\"desktop:20px;\" main_heading_style=\"font-style:italic;font-weight:700;\"]8 meter boven de grond op een oude spoorweg[/ultimate_heading][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fnewyork%2Fnewyorkcity%2Fparken%2Fthe-high-line%2F|title:The%20High%20Line\" btn_align=\"ubtn-center\" btn_size=\"ubtn-small\" btn_bg_color=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_shadow=\"shd-bottom\" btn_shadow_color=\"#0a0a0a\" btn_shadow_size=\"5\" btn_font_family=\"font_family:Rubik Mono One|font_call:Rubik+Mono+One\" btn_font_size=\"desktop:18px;\"][vc_empty_space height=\"250px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"86\"][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"Intrepid Sea, Air and Space Museum","post_link":"https://www.heyusa.com/nl/intrepid-sea-air-space-museum-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Intrepid Sea air and space museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/Intrepid-Sea-air-and-space-museum-2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}.vc_custom_1625324880871{padding-top: 25px !important;padding-right: 25px !important;padding-bottom: 25px !important;padding-left: 25px !important;background-color: #b34a4c !important;}","%_edit_lock%":"1667988723:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"16","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Intrepid Sea, Air and Space Museum","%_yoast_wpseo_title%":"%%title%% in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een tof en interactief museum in New York is het Intrepid Sea, Air and Space Museum. Tips voor je bezoek aan het Intrepid Sea, Air and Space Museum.","%_yoast_wpseo_linkdex%":"64","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"Pier 86, W 46th St, New York, NY 10036, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7645266","%_wpgmp_metabox_longitude%":"-73.99960759999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"3496","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1677015528","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Musea New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":1591,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Museum of Modern Art- MoMA","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Moma\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/Moma1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Museum of Modern Art- MoMA</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"11 W 53rd St, New York, NY 10019, Verenigde Staten","location":{"lat":"40.7614327","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.97762159999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/museum-of-modern-art-moma-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text]<strong>Het Museum of Modern Art- MoMA is het meest toonaangevende museum ter wereld voor moderne en hedendaagse kunst. In het museum vind je voornamelijk schilderkunst en beeldhouwkunst van de twintigste eeuw, aangevuld met films, foto\u2019s en een uitgebreide boekencollectie. In 1929 werd voor het eerst begonnen met het verzamelen van kunstwerken en tegenwoordig bevat de collectie zo\u2019n 20.000 moderne en hedendaagse kunstwerken. Er is een permanente collectie die zeer de moeite waard is om te bekijken en daarnaast zijn er ook regelmatig interessante exposities en events in het MoMA. </strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Midtown Manhattan | 11 W 53rd Street\"][thb_iconlist icon=\"fas fa-subway\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"5th Avenue - 53 Street Station | E\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fskip-the-line-tickets-museum-of-modern-art-t14885%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dmomaskiptheline\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_column_text]\r\n<h4 style=\"text-align: center;\">De plek voor moderne en hedendaagse kunst</h4>\r\n<p style=\"text-align: center;\">Het Museum of Modern Art- MoMA is het museum voor liefhebbers van hedendaagse kunst. Met meer dan 20.000 kunstwerken ben je wel even zoet in het museum.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Hedendaagse kunst\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Het museum voor moderne kunst\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"5390\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Museum of Modern Art- MOMA\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"De vijfde verdieping \u2013 Paintings &amp; Sculpture 1880s-1940s\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Op deze verdieping hangen echte klassiekers in de hedendaagse kunst zoals Pablo Picasso\u2019s Les Demoiselles d\u2019Avignon en de Sterrennacht van Vincent van Gogh. Ook werken van kunstenaars als Henri Matisse, Monet en Salvador Dali vind je op de vijfde verdieping. Centraal staan hier kunst en schilderwerken tussen 1880 en 1940.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Vierde verdieping \u2013 Paintings &amp; Sculpture 1940s-1980s\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Een andere verdieping die populair is bij bezoekers is de vierde verdieping. Hier zijn de wat meer recentere kunstwerken te vinden. Kunstenaars als Jackson Pollock en Andy Warhol schitteren op deze verdieping. Door boven in het museum te beginnen, volg je zo de geschiedenis van de moderne kunst.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Shop MoMA\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Ook al ben je misschien wat minder ge\u00efnteresseerd in moderne kunst, vind je een museum niet zo boeiend of heb je weinig tijd, sla toch de <a href=\"https://store.moma.org/\" target=\"_blank\" rel=\"noopener\">MoMA shop</a> niet over. Er zitten verschillende locaties in New York en het is zeker de moeite waard om er een kijkje te nemen. Vaak zijn museumshops niet bijster interessant of budgetvriendelijk, maar dat is bij MoMA niet het geval. Je vindt er veel praktische design dingen en interessante boeken.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"250px\"][ultimate_heading main_heading=\"THE HIGH LINE\" heading_tag=\"p\" main_heading_color=\"#ffffff\" sub_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Arvo|font_call:Arvo|variant:700italic\" main_heading_line_height=\"desktop:45px;\" sub_heading_font_family=\"font_family:Rubik Mono One|font_call:Rubik+Mono+One\" sub_heading_font_size=\"desktop:20px;\" main_heading_style=\"font-style:italic;font-weight:700;\"]8 meter boven de grond op een oude spoorweg[/ultimate_heading][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fnewyork%2Fnewyorkcity%2Fparken%2Fthe-high-line%2F|title:The%20High%20Line\" btn_align=\"ubtn-center\" btn_size=\"ubtn-small\" btn_bg_color=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_shadow=\"shd-bottom\" btn_shadow_color=\"#0a0a0a\" btn_shadow_size=\"5\" btn_font_family=\"font_family:Rubik Mono One|font_call:Rubik+Mono+One\" btn_font_size=\"desktop:18px;\"][vc_empty_space height=\"250px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"86\"][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"Museum of Modern Art- MoMA","post_link":"https://www.heyusa.com/nl/museum-of-modern-art-moma-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Moma\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/Moma1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1667988618:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"16","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Museum of Modern Art- MoMA","%_yoast_wpseo_title%":"%%title%% in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Het museum voor moderne kunst in New York is het Museum of Modern Art- MoMA. Tips voor je bezoek aan het Museum of Modern Art- MoMA.","%_yoast_wpseo_linkdex%":"76","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"MoMA\"]","%_wpgmp_location_address%":"11 W 53rd St, New York, NY 10019, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7614327","%_wpgmp_metabox_longitude%":"-73.97762159999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"3491","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1677015531","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Musea New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":1588,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Solomon R. Guggenheim Museum","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Guggenheim\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/Guggenheim2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Solomon R. Guggenheim Museum</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"1071 5th Ave, New York, NY 10128, Verenigde Staten","location":{"lat":"40.7829796","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.9589706","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/guggenheim-museum-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text][/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_empty_space height=\"25px\"][ultimate_heading main_heading=\"Het Guggenheim in New York\" main_heading_color=\"#282828\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]<strong>Een van de opmerkelijkste gebouwen is misschien wel het ronde Solomon R. Guggenheim Museum in New York. Daardoor is het gebouw een museumstuk op zich geworden. Het spiraalvormige gebouw is zowel aan de binnen- als buitenkant uniek om te zien. De tentoonstellingen zijn door de vorm van het gebouw in een spiraalvormige helling te bezoeken. Het centrale deel van het museum bevat een grote lichtkoepel. In het museum vind je de priv\u00e9collectie van Solomon R. Guggenheim. In deze collectie zitten enkele topstukken als schilderijen van Picasso en Karel Appel.\r\n</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Upper East Side | 1071 5th Avenue\"][thb_iconlist icon=\"fas fa-subway\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"86th Street | 4 | 5 | 6\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Boek je tickets\" btn_link=\"url:https%3A%2F%2Fwww.viator.com%2Ftours%2FNew-York-City%2FSolomon-R-Guggenheim-Museum-with-Skip-the-Line-Access%2Fd687-42533SRGM%3Fpid%3DP00074479%26mcid%3D42383%26medium%3Dlink%26campaign%3Dsalomonguggenheim|title:Boek%20je%20tickets|target:_blank\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:18px;\" btn_line_height=\"desktop:20px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Een van de meest toonaangevende musea ter wereld\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Maak niet alleen kennis met de priv\u00e9collectie van Solomon R. Guggenheim in het Solomon R. Guggenheim Museum in New York, maar ook met een van de leukste gebouwen om kunst te bekijken! Aan de rand van <a href=\"https://www.heyusa.com/nl/new-york/central-park/\" target=\"_blank\" rel=\"noopener noreferrer\">Central Park</a> vind je dit spiraalvormige museum vol met prachtige kunstwerken.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Het iconische Guggenheim gebouw\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Aan Fifth Avenue in New York\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"2769\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][ultimate_heading main_heading=\"Wat je niet mag missen\" heading_tag=\"p\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"In het Guggenheim New York City\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:300;\"][/ultimate_heading][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Guggenheim Collectie\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Van de collectie van Solomon R. Guggenheim zijn zo\u2019n 600 kunstwerken te vinden in het museum in New York. Het zijn voornamelijk vroeg modernistische kunstwerken. In deze collectie zit ook een schilderij van Piet Mondriaan en nog meer belangrijke kunstwerken uit Europa.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Thannhouser Collectie\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In 1963 werd de collectie van Solomon R. Guggenheim uitgebreid door een collectie van impressionistische, post-impressionistische en moderne Franse meesterwerken als schenking van Justin K. Thannhauser. Door een vriendschap tussen Thannhauser en Guggenheim werden de schilderijen nagelaten aan het Guggenheim. Hierdoor hangen er onder andere Picasso\u2019s en van Goghs in het Guggenheim.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][ultimate_heading main_heading=\"Karl Nierenhof Estate\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:30px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In 1948 kocht de Guggenheim Stichting de gehele collectie van New York kunstdealer Karl Nierendorf. De collectie van het Guggenheim werd hierdoor uitgebreid met Duitse en Oostenrijkse expressionistische en surrealistische werken.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Rond, rond en rond\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][ultimate_heading main_heading=\"Het iconische Guggenheim gebouw\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"3487\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Ook leuk in New York City:\" heading_tag=\"p\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][fullwidth_row][thb_postgrid columns=\"4\" source=\"post_type:post|by_id:1594,1312,408,1559\"][/vc_column][/vc_row]","post_title":"Solomon R. Guggenheim Museum","post_link":"https://www.heyusa.com/nl/guggenheim-museum-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Guggenheim\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/Guggenheim2-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1667988541:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"16","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Solomon R. Guggenheim Museum","%_yoast_wpseo_title%":"Solomon R. Guggenheim Museum New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een van de bekendste musea is het Solomon R. Guggenheim Museum in New York. Tips voor je bezoek aan het Guggenheim Museum in New York.","%_yoast_wpseo_linkdex%":"71","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_wpgmp_location_address%":"1071 5th Ave, New York, NY 10128, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7829796","%_wpgmp_metabox_longitude%":"-73.9589706","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_thumbnail_id%":"3488","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1677015533","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Musea New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":1584,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Tickets One World Observatory","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"One World Observatory\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/one-world-observatory-1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Tickets One World Observatory</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"285 Fulton St, New York, NY 10007, Verenigde Staten","location":{"lat":"40.7127431","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-74.0133795","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/one-world-observatory-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Tickets One World Observatory\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">One World Observatory is een de highlights in de skyline van New York. Het is het grootste gebouw op het westelijk halfrond. Daarnaast is het een gebouw waar natuurlijk een stukje historie aanhangt. Waar je vroeger het World Trade Center kon bezoeken voor het uitzicht is dat sinds 9/11 natuurlijk niet meer mogelijk. De Freedom Tower of ook wel One World Trade Center is daarvoor in de plek gekomen en zoals Amerikanen dat kunnen is het een unieke ervaring geworden die je niet mag missen. Bestel je <a href=\"https://www.getyourguide.nl/new-york-l59/new-york-one-world-observatory-entreeticket-t52132/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=oneworldtradeintrotekst\" target=\"_blank\" rel=\"noopener\">ticket voor het sobservatieplatform One World Observatory</a> en bekijk de skyline van Lower Manhattan.</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-arrows-v\"]541 meter hoog[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-building\"]104 verdiepingen[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf \u20ac39 per persoon[/ultimate_icon_list_item][/ultimate_icon_list][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Koop van te voren je ticket zodat je de rijen over kunt slaan. Ik kocht in eerste instantie een ticket voor een dag waarop het bewolkt was en kon zonder problemen omruilen voor een zonnige dag.\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fnew-york-one-world-observatory-entrance-ticket-t52132%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Doneworldbovenin|title:Bestel%20je%20tickets|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Enjoy the view!\" font_container=\"tag:div|font_size:75|text_align:center|color:%23ffffff|line_height:2\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Uitzicht van het hoogste gebouw van New York\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"15px\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fnew-york-one-world-observatory-entrance-ticket-t52132%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Doneworldmiddelstefoto|title:Boek%20hier%20je%20ticket|target:_blank\" btn_align=\"ubtn-center\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"3966\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tickets voor One World Observatory in New York\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Je kunt het ticket voor het One World Observatory op verschillende manieren aanschaffen. Het makkelijkste is om <a href=\"https://www.getyourguide.nl/new-york-l59/new-york-one-world-observatory-entreeticket-t52132/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=oneworldtradeintekst\" target=\"_blank\" rel=\"noopener\">online tickets</a> te kopen. Hierdoor ben je flexibel en kun je de wachtrij overslaan. Je kunt zelfs kort van te voren nog online een ticket kopen, deze kun je laten scannen op je telefoon.</span>[/vc_column_text][vc_custom_heading text=\"Online tickets bestellen\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Het bezoeken van het One World Observatory gaat op basis van tijdslots. Je koopt een kaartje voor een bepaalde tijd om naar boven te gaan.\u00a0</span>[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fnew-york-one-world-observatory-entrance-ticket-t52132%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Doneworldtradeonderin|title:Boek%20hier%20je%20ticket|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"1/2\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Het observatieplatform is overdekt en daardoor bekijk je de skyline vanachter het glas. Foto's maken zonder reflectie is daardoor soms lastig. Wil je de skyline goed fotograferen met een smartphone? Zet je telefoon dan helemaal tegen het glas, hierdoor zie je veel minder (en als het goed is zelfs geen) reflectie!\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"In het One World Observatory lunchen of dineren met uitzicht over de skyline, een unieke ervaring. Krijg een twee gangen lunch of drie gangen diner en geniet ondertussen van het uitzicht over de stad.\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Handige informatie voor je bezoek\" font_container=\"tag:div|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong> De hoofdingang is aan West Street (hoek West en Vesey Street)</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]\r\n<ul>\r\n \t<li style=\"list-style-type: none;\">\r\n<ul>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">4 januari \u2013 30 april: 9.00 tot 21.00 uur</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">1 mei \u2013 4 september: 8.00 tot 21.00 uur</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">5 september - 20 december: 9.00-21.00 uur</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">21 december-\u00a0 3 januari: 8.00-20.00 uur</span></li>\r\n</ul>\r\n</li>\r\n</ul>\r\n[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<strong>Openingstijden kunnen afwijken tijdens feestdagen</strong>[/ultimate_icon_list_item][/ultimate_icon_list][vc_custom_heading text=\"Wat is het beste moment om het One World Observatory te bezoeken?\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Overdag en \u2018s avonds, het One World Observatory is 365 dagen per jaar geopend globaal van 9.00-20.00 uur, dit verschilt per seizoen. Wanneer je in Lower Manhattan bent, is het een goede optie om <a href=\"https://heyusa.com/nl/newyork/newyorkcity/musea/9-11-museum-memorial/\" target=\"_blank\" rel=\"noopener noreferrer\">9/11 memorial en museum</a> te combineren. </span><span style=\"font-weight: 400;\">\r\n</span><span style=\"font-weight: 400;\">\r\n</span><b>De beste tijden voor een bezoek:\u00a0</b>\r\n<ul>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Van 08.00 / 9.00 - 10.00 uur - net voor de drukte aan</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Van 19:00 uur - 20.00 / 21:00 uur - na alle drukte\u00a0</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Op werkdagen, in het weekend is het een stuk drukker</span></li>\r\n</ul>\r\n[/vc_column_text][vc_custom_heading text=\"Korting op tickets voor het Empire State Building\" font_container=\"tag:h2|font_size:15|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Er zijn mogelijkheden om het One World Observatory te bezoeken met korting. Hiervoor kun je het beste een <a href=\"https://www.heyusa.com/nl/voordeelpassen-new-york/\">voordeelpas van New York</a> aanschaffen. Je hoeft niet een specifieke datum al vast te leggen, maar moet wel een tijdstip reserveren.[/vc_column_text][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"5/6\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"541m hoog\" font_container=\"tag:div|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Hoogste gebouw van New York\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"15442\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1613034013594{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Over One World Observatory\" font_container=\"tag:div|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">Het One World Observatory is met zijn 541 meter het hoogste gebouw van het Amerikaanse continent. Het is zelfs het op vijf na hoogste gebouw ter wereld. Inclusief de bliksemafleider is het gebouw 546 meter hoog. De 541 meter, of ook wel 1776 feet, verwijzen naar het jaar waarin de Onafhankelijkheidsverklaring werd getekend.\r\n</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Stukje ondergronds\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Het observatiedek van het One World Observatory ligt op de 102e verdieping van het gebouw. In totaal zijn er 104 verdiepingen, maar stiekem zijn dat er in werkelijkheid maar 94 bovengrondse. Het observatiedek bestaat uit drie verdiepingen, met elk een uitzicht van 360 graden.\u00a0</span>\r\n\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Stukje geschiedenis\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Het One World Trade Center staat natuurlijk nog maar relatief kort in de skyline van Manhattan. In acht jaar werd het gebouw de grond uit getoverd. Dertien jaar na de aanslagen op<a href=\"https://www.heyusa.com/nl/new-york-city/9-11-museum-memorial/\" target=\"_blank\" rel=\"noopener noreferrer\"> 9/11</a> werd het gapende gat opgevangen door het One World Trade Center. Binnen in het One World Trade Center vind je het One World Observatory, het observatieplatform in het zuiden van Manhattan.\u00a0</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Het uitzicht vanaf het One World Observatory\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Vanaf het One World Observatory heb je een uitzicht over de stad vanuit Lower Manhattan. Je kunt onder andere het Vrijheidsbeeld, de Brooklyn Bridge zien vanuit de lucht. Een totaal ander uitzicht dan vanaf het Empire State Building of Top of the Rock. Daarnaast zijn New Jersey en Brooklyn goed te zien vanaf het One World Observatory.\u00a0</span>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1620887540936{background-color: #dadada !important;}\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][ultimate_heading main_heading=\"Veelgestelde vragen over het One World Trade Center\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:800;\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][vc_toggle title=\"Wat kost een ticket voor One World Trade Center?\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]Je hebt tickets vanaf 40 euro[/vc_toggle][vc_toggle title=\"Wat is de beste tijd voor een bezoek aan One World Trade Center?\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]Je kunt het beste overdag het One World Trade Center bezoeken. Doordat het overdekt is, heb je op dit tijdstip het beste uitzicht over New York[/vc_toggle][vc_toggle title=\"Is One World Trade Center de moeite waard?\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]Een bezoek aan One World Trade Center is een ervaring op zich. Een stukje geschiedenis en daarbij begint de ervaring al in de lift naar boven. Daarnaast is het platform geschikt voor mensen met hoogtevrees doordat het binnen is.[/vc_toggle][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"80%\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Foto's van One World Observatory\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\" margin_design_tab_text=\"\"][/ultimate_heading][thb_image_slider images=\"16885,16886,15442,13005,1578,15441\"][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York\" font_container=\"tag:div|font_size:55|text_align:center|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:-3396,-1875,-1767,-1647,10251,1484,1559,10752\"][/vc_column][/vc_row]","post_title":"Tickets One World Observatory","post_link":"https://www.heyusa.com/nl/one-world-observatory-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"One World Observatory\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/one-world-observatory-1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1613034013594{background-color: #ededed !important;}.vc_custom_1620887540936{background-color: #dadada !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}","%_edit_last%":"2","%_edit_lock%":"1690441912:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"14","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":[{"title":"Foto credit: Julienne Schaer/NYC & Company","post_source_url":"http://www.nycgo.com"}],"%_thumbnail_id%":"15441","%_yoast_wpseo_focuskw%":"Tickets One World Observatory","%_yoast_wpseo_title%":"Tickets One World Observatory in New York%%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Het One World Observatory in New York is een aanrader om de skyline te bekijken. Koop hier je tickets voor het One World Observatory.","%_yoast_wpseo_linkdex%":"78","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"One World Observatory New York\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"285 Fulton St, New York, NY 10007, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7127431","%_wpgmp_metabox_longitude%":"-74.0133795","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%_yoast_indexnow_last_ping%":"1690442015","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_primary_category%":"","taxonomy=category":"Bezienswaardigheden New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":1571,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Tickets Top of the Rock","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Top of the Rock bij Rockefeller Center New York\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/top-of-the-rock-newyork-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Tickets Top of the Rock</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"285 Fulton St, New York, NY 10007, Verenigde Staten","location":{"lat":"40.7127431","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-74.0133795","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/new-york/top-of-the-rock/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Tickets Top of Rock\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Een letterlijke highlight tijdens je stedentrip</span><span style=\"font-weight: 400;\"> is een bezoek aan de Top of the Rock in New York. In New York heb je vijf mogelijkheden om de skyline van de stad vanuit de hoogte te bekijken en een daarvan is boven op het Rockefeller Center. Top of the Rock is misschien wel de leukste van de traditionele uitzichtpunten. Waarom? Vanaf de Top of the Rock heb je uitzicht over Central Park en zie je het Empire State Building terug in de skyline van de stad. Het meest complete uitzicht over de skyline van New York! Boek snel je <a href=\"https://www.getyourguide.nl/top-of-the-rock-l3361/new-york-top-of-the-rock-observatie-dek-ticket-t37483/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=topofrockintrotekst\" target=\"_blank\" rel=\"noopener\">tickets voor Top of Rock</a> om deze ervaring niet te missen! En ondertussen hebben wij allerlei handige tips voor je bezoek aan Top of Rock.</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-arrows-v\"]259 meter hoog[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-building\"]70 verdiepingen[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf \u20ac40 per persoon[/ultimate_icon_list_item][/ultimate_icon_list][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"5/6\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Bestel van te voren tickets. Zeker in het hoogseizoen heb je kans dat het druk is en dan mis je een van de mooiste uitzichten in New York! Na aankoop ontvang je een ticket en daarmee kun je de ticketbalie en wachtrij overslaan.\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:100%20light%20regular%3A100%3Anormal\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Ftop-of-the-rock-observation-deck-l3361%2Ftop-of-the-rock-observation-deck-t37483%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dtopofrockbovenstebanner|title:Bestel%20je%20tickets%20voor%20Top%20of%20the%20Rock|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"259m hoog\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"20e hoogste gebouw van New York\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Ftop-of-the-rock-l3361%2Fnew-york-top-of-the-rock-observatie-dek-ticket-t37483%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26cmp%3Dtopofrockbanner|title:Tickets%20voor%20Top%20of%20Rock|target:_blank\" btn_align=\"ubtn-center\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"3937\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Tickets voor Top of the Rock in New York\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Dag en nacht Top of the Rock bezoeken op 1 ticket!\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Net als het Empire State Building kun je een <a href=\"https://www.getyourguide.nl/top-of-the-rock-l3361/new-york-top-of-the-rock-observatie-dek-ticket-t37483/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=topofrockintekst\" target=\"_blank\" rel=\"noopener\">voordelig dag en nacht ticket</a> krijgen om Top of the Rock tweemaal op dezelfde dag te bezoeken. Je mag met 1 ticket, tweemaal naar boven. Ideaal om de stad te fotograferen bij daglicht en de fonkelende lichtjes \u2018s avonds. En 's avonds de stad vanuit het donker te bekijken is zeker een aanrader!</span>[/vc_column_text][vc_custom_heading text=\"Online tickets bestellen Top of Rock\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Top of the Rock bezoeken gaat op basis van tijdslots, je koopt tickets voor een bepaalde tijd. Ideaal om een tijd vast te leggen om net voor zonsondergang naar boven te gaan. Ben je te laat? Dan mag je meestal in het eerstvolgende tijdslot naar boven.</span>\r\n\r\n[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Ftop-of-the-rock-observation-deck-l3361%2Ftop-of-the-rock-observation-deck-t37483%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dtopofrockonderstebanner|title:Bestel%20je%20tickets%20voor%20Top%20of%20the%20Rock|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"1/2\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Loop in de ochtend langs Rockefeller Center en boek je timeslot een uur voor zonsondergang. Zo kun je de stad in het licht zien en de zonsondergang. Wacht nog even tot de zon helemaal onder is. Zeker op warme dagen krijg je dan een fantastisch licht te zien.\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:300%20light%20regular%3A300%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/2\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Praktische informatie Top of Rock\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>50th Street tussen Fifth en 6th Avenue</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Dagelijks van 08.00 uur tot middernacht</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<strong>Openingstijden kunnen afwijken tijdens Kerst en Oud en Nieuw</strong>[/ultimate_icon_list_item][/ultimate_icon_list][vc_custom_heading text=\"Korting op tickets voor Top of Rock\" font_container=\"tag:h2|font_size:15|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Er zijn mogelijkheden om het Top of Rock te bezoeken met korting. Hiervoor kun je het beste een <a href=\"https://www.heyusa.com/nl/voordeelpassen-new-york/\">voordeelpas van New York</a> aanschaffen. Je hoeft niet een specifieke datum al vast te leggen, maar moet wel een tijdstip reserveren.[/vc_column_text][vc_custom_heading text=\"Wat is het beste moment om Top of the Rock te bezoeken?\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Top of the Rock is 365 dagen per jaar geopend van 8.00 uur \u2018s morgens tot 23.15 uur \u2018s avonds. De capaciteit van Top of the Rock is aanzienlijk groter vergeleken met het Empire State Building, waardoor je vrijwel niet in de rij zult te staan.</span><span style=\"font-weight: 400;\">\r\n</span><span style=\"font-weight: 400;\">\r\n</span><b>De beste tijden om Top of the Rock te bezoeken:\u00a0</b>\r\n<ul>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Weinig tot geen wachtrijen gedurende de gehele dag</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Een uur voor schemering, je hebt dan dag- en avond in 1x!</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">In het weekend is het er meestal drukker</span></li>\r\n</ul>\r\n[/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Enjoy the view!\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:75px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:4px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Lower Manhattan net na zonsondergang\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"25px\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"1569\"][/vc_column][/vc_row][vc_row bg_type=\"bg_color\" bg_color_value=\"#ededed\" css=\".vc_custom_1612946867021{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Top of the Rock in New York\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">Top of Rock bevindt zicht in het Rockefeller Center in New York. Op een hoogte van 259 meter kijk je uit over de skyline van New York. Geniet van een panorama van 360 graden en zie alle belangrijke wolkenkrabbers voorbij komen. Hoewel je op de hoogste wolkenkrabber staat van het Rockefeller Center, ben je niet op het hoogste punt van de stad. Die eer heeft het One World Trade Center met 541 meter.</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Rockefeller Center\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Rockefeller Center, bestaande uit 14 gebouwen, was in 1930 het grootste private bouwproject ter de wereld en ongezien van omvang destijds. Het duurde slechts 9 jaar om Rockefeller Center te bouwen. Het complex is vernoemd naar de oprichter John D. Rockefeller Jr.\u00a0</span>\r\n\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"30 Rock in het Top of Rock\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Top of the Rock bevindt zich bovenin \u201830 Rock\u2019 het hoogste gebouw van het complex. Vanaf de 68e en 70e etage, dan ben je inmiddels op 259 meter hoogte, heb je een geweldig panoramisch uitzicht over Manhattan. Van alle uitzichtpunten in de stad, is dit onze favoriet!\u00a0</span>\r\n\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Het uitzicht vanaf het Top of Rock\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Ondanks dat Top of the Rock 122 meter lager is dan het Empire State Building, heb je vanaf dit observatiedek, naar onze mening, het allerbeste uitzicht van New York! Je hebt\u00a0 hier zonder obstakels een panoramisch uitzicht op Central Park, Times Square, het Empire State Building, Midtown en Downtown New York. </span><span style=\"font-weight: 400;\">\r\n</span><b>Tip:</b><span style=\"font-weight: 400;\"> Kijk omhoog wanneer je in de lift stapt naar boven ;)</span>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1620887540936{background-color: #dadada !important;}\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][ultimate_heading main_heading=\"Veelgestelde vragen over Top of Rock\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:800;\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][vc_toggle title=\"Wat kost een ticket voor Top of Rock?\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]Je hebt tickets vanaf 40 euro. Top of Rock zit bij sommige voordeelpassen inbegrepen.[/vc_toggle][vc_toggle title=\"Wat is de beste tijd voor een bezoek aan Top of Rock?\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]Wij vinden de beste tijd een 1,5-1 uur voor zonsondergang. Hierdoor heb je 'best of both worlds' en kun je de stad langzaam donker zien worden.[/vc_toggle][vc_toggle title=\"Is Top of Rock de moeite waard?\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]We snappen dat je niet alle uitzichtpunten kunt bezoeken in New York. Top of Rock is volgens ons een aanrader omdat je in je uitzicht het Empire State Building kunt zien \u00e9n aan de andere kant Central Park.[/vc_toggle][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"80%\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Foto's van Top of Rock\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][thb_image_slider images=\"3939,1569,1568,1563,567\"][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York\" font_container=\"tag:div|font_size:50|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:-3408,-1759,1484,-520,10251,1571,10752\"][/vc_column][/vc_row]","post_title":"Tickets Top of the Rock","post_link":"https://www.heyusa.com/nl/new-york/top-of-the-rock/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Top of the Rock bij Rockefeller Center New York\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/top-of-the-rock-newyork-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1612946867021{background-color: #ededed !important;}.vc_custom_1620887540936{background-color: #dadada !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}","%_edit_last%":"2","%_edit_lock%":"1690818126:1","%_wpb_vc_js_status%":"true","%post-primary-category%":"14","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":[{"title":"Foto credit: Julienne Schaer/NYC & Company","post_source_url":"http://www.nycgo.com"}],"%_thumbnail_id%":"3939","%_yoast_wpseo_focuskw%":"Tickets Top of Rock","%_yoast_wpseo_title%":"Tickets Top of Rock in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Het Top of Rock in New York is een van de highlights in New York. Tips voor je bezoek aan de Top of Rock in New York en tickets voor Top of Rock","%_yoast_wpseo_linkdex%":"75","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Top of Rock in New York\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"285 Fulton St, New York, NY 10007, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7127431","%_wpgmp_metabox_longitude%":"-74.0133795","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1690440675","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_primary_category%":"","taxonomy=category":"Bezienswaardigheden New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":1559,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Tickets Empire State Building","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Empire New York\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/05/Empire-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Tickets Empire State Building</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","content":"Boottocht van 90 minuten over de Hudson en East River","address":"Empire State Building, New York, NY 10001, Verenigde Staten","location":{"lat":"40.7485452","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.98576349999999","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/empire-state-building-new-york/","zoom":12,"extra_fields":{"post_excerpt":"Boottocht van 90 minuten over de Hudson en East River","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][fullwidth_row content_width=\"85%\"][/vc_column][vc_column width=\"1/2\"][vc_empty_space height=\"25px\"][vc_custom_heading text=\"Tickets Empire State Building\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">\u00c9\u00e9n van de iconen in de skyline van New York is ongetwijfeld het Empire State Building. De beroemdste bezoeker, by far, is <strong>King Kong</strong> in de gelijknamige film uit 1933 en de remake in 2005. Het Empire State Building is dan ook een must-do attractie om te bezoeken tijdens je citytrip in New York. Je kunt vanaf de 86e etage heel Manhattan zien, op de foto met King Kong of je hoogtevrees overwinnen. Vanaf het Empire heb je niet alleen een fantastisch uitzicht op New York, je bevindt je ook nog eens in \u00e9\u00e9n van de iconische gebouwen van New York. Bestel snel je <a href=\"https://www.getyourguide.nl/empire-state-building-l2608/skip-the-line-empire-state-building-observatory-kaart-t6195/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;cmp=empireintrotekst\" target=\"_blank\" rel=\"noopener\">tickets voor het Empire State Building</a> en lees onze tips voor een bezoek aan het Empire.</span>[/vc_column_text][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-arrows-v\"]381 meter hoog (443m inclusief antenne)[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-building\"]102 verdiepingen[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-calendar\"]365 dagen per jaar geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\"]Vanaf \u20ac43 per persoon[/ultimate_icon_list_item][/ultimate_icon_list][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"5/6\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Bestel van te voren tickets. Zeker in het hoogseizoen heb je kans dat het druk is en het Empire wil je natuurlijk niet missen! Na aankoop ontvang je een ticket en daarmee kun je de ticketbalie en wachtrij overslaan.\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:100%20light%20regular%3A100%3Anormal\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fempire-state-building-l2608%2Fskip-the-line-empire-state-building-observatory-kaart-t6195%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dempirestatenormaleticketsbovenbutton|title:Bestel%20je%20tickets%20voor%20het%20Empire%20State%20Building|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\" btn_line_height=\"desktop:1px;\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1640065446664{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"381m hoog\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"7e hoogste gebouw van New York\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fempire-state-building-l2608%2Fskip-the-line-empire-state-building-observatory-kaart-t6195%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dempirestatenormaleticketsbuttonfoto|title:Bestel%20tickets%20voor%20het%20Empire%20State%20Building|target:_blank\" btn_align=\"ubtn-center\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"274\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Empire State Building tickets\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Dag en nacht het Empire State bezoeken op 1 ticket!\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:100%20light%20regular%3A100%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Net als Top of the Rock kun je een <a href=\"https://www.getyourguide.nl/new-york-l59/ervaar-het-empire-state-building-overdag-en-s-avonds-t120557/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=empirestatedagennachttekst\" target=\"_blank\" rel=\"noopener\">voordelig dag en nacht ticket</a> kopen om het Empire State Building tweemaal op dezelfde dag te bezoeken. Overdag voor prachtige foto\u2019s van het uitzicht en de skyline, \u2018s avonds voor het uitzicht over verlicht New York. Bezoek tussen 8.00-21.00 uur het Empire State Building voor de eerste keer en tussen 21.00-2.00 uur voor de tweede keer met de voordelige dag-en avondtickets.\u00a0</span>[/vc_column_text][ult_buttons btn_title=\"Bestel je tickets voor een dag en nacht bezoek\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fnew-york-l59%2Fervaar-het-empire-state-building-overdag-en-s-avonds-t120557%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dempirestatedagennachtbutton|title:Bestel%20tickets%20voor%20het%20Empire%20State%20Building|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_custom_heading text=\"Voorrangstickets voor het Empire State Building\" font_container=\"tag:h3|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:100%20light%20regular%3A100%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Je kunt het Empire State Building bezoeken op de manier die jij wilt! Het fijne aan <a href=\"https://www.getyourguide.nl/empire-state-building-l2608/skip-the-line-empire-state-building-observatory-kaart-t6195/?partner_id=DMD2VL4&amp;utm_medium=online_publisher&amp;placement=%22other%22&amp;cmp=empirestatenormaleticketstekst\">online tickets</a> kopen is dat het je vooral veel tijd scheelt. Je kunt hiermee, de vaak lange rij, gewoon passeren op weg naar de lift. Daarnaast is online kopen ook nog eens goedkoper!\u00a0</span>[/vc_column_text][ult_buttons btn_title=\"Bestel je normale tickets voor het Empire State Building\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fempire-state-building-l2608%2Fskip-the-line-empire-state-building-observatory-kaart-t6195%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dempirestatenormaleticketsbutton|title:Bestel%20tickets%20voor%20het%20Empire%20State%20Building|target:_blank\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"1/2\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Ben je een ochtendmens? Ga dan vroeg naar het Empire State Building. Het is er dan rustig en je hebt alle tijd om de skyline van Manhattan te bekijken. Wil je een unieke ervaring? Ga dan net voor zonsondergang omhoog, je ziet dan de stad overdag en langzaam zie je de stad donker worden met alle lichten.\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:100%20light%20regular%3A100%3Anormal\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/3\"][vc_custom_heading text=\"Empire State Building bezoeken - handige tips\" font_container=\"tag:h2|font_size:30|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][ultimate_icon_list icon_size=\"18\" icon_margin=\"15\"][ultimate_icon_list_item icon=\"Defaults-map-marker\"]<strong>20 West 34th Street</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-clock-o\"]<strong>Dagelijks van 08.00 uur tot 02.00 uur</strong>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<strong>Openingstijden kunnen afwijken tijdens Kerst en Oud en Nieuw</strong>[/ultimate_icon_list_item][/ultimate_icon_list][vc_custom_heading text=\"Korting op tickets voor het Empire State Building\" font_container=\"tag:h2|font_size:15|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Er zijn mogelijkheden om het Empire State Building te bezoeken met korting. Hiervoor kun je het beste een <a href=\"https://www.heyusa.com/nl/voordeelpassen-new-york/\">voordeelpas van New York</a> aanschaffen. Je hoeft niet een specifieke datum al vast te leggen, maar moet wel een tijdstip reserveren.[/vc_column_text][vc_custom_heading text=\"Beste moment om het Empire State Building te bezoeken\" font_container=\"tag:h2|font_size:15|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Ochtend, avond en nacht, het Empire State Building is 365 dagen per jaar geopend van 8:00 uur \u2018s morgens tot 02.00 uur \u2018s nachts. Van de momenteel vijf wolkenkrabbers met uitzicht, is het Empire het langst geopend. Een bezoekje aan het Empire State Building kun je dus geheel naar eigen keuze inplannen en past eigenlijk altijd wel in je planning. </span><span style=\"font-weight: 400;\">\r\n</span><span style=\"font-weight: 400;\">\r\n</span><b>De beste tijden om het Empire State Building te bezoeken:\u00a0</b>\r\n<ul>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Van 08.00 - 10.00 uur - net voor de drukte aan</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Van 19:00 uur - 21:00 uur - na alle drukte\u00a0</span></li>\r\n \t<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Op werkdagen, in het weekend is het een stuk drukker</span></li>\r\n</ul>\r\n[/vc_column_text][vc_row_inner thb_max_width=\"\"][vc_column_inner width=\"5/6\" box_shadow=\"large-shadow\" thb_border_radius=\"10px\" css=\".vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}\"][vc_custom_heading text=\"Tip:\" font_container=\"tag:div|font_size:15|text_align:left|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Wil je jouw vriend of vriendin ten huwelijk vragen? Doe dit dan op donderdag en in het weekend! Vanaf 22:00 uur \u2018s avonds speelt een saxofonist live op de 86e verdieping!\" font_container=\"tag:div|font_size:20|text_align:left|color:%23282828\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:100%20light%20regular%3A100%3Anormal\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Enjoy the view!\" heading_tag=\"div\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:65px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:70px;\"][/ultimate_heading][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Je kunt One World Trade Center zelfs zien!\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"1531\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1640065243115{background-color: #ededed !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Het Empire State Building in New York\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\"><span style=\"font-weight: 400;\">Met 381 meter hoog (443m inclusief antenne) behoort het Empire State Building nog steeds tot een van de hoogste wolkenkrabbers van New York. De bouw duurde precies 1 jaar en 45 dagen, ongekend en onge\u00ebvenaard snel. De bouw van het Empire State Building ging van start in 1930 en werd in 1931 opgeleverd. Tot de bouw van de North Tower van het World Trade Center in 1971 bleef het Empire het hoogste ter wereld.</span></p>\r\n[/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Verdiepingen en liften in het Empire State Building\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Het Empire State Building heeft 102 verdiepingen, 73 liften, twee observatie dekken en is het 35 hoogste gebouw ter wereld en het 7e hoogste in de 'Big Apple'. In 2019 werd een $165 miljoen kostende renovatie van de observatieplatformen afgerond en is zelfs de lift omhoog naar het 86e een attractie op zich!\u00a0</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Betekenis van de verschillende kleuren lampen op het Empire\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Wanneer je door New York loopt, is het Empire State Building vaak verlicht in bepaalde kleuren. Het gebouw bevat LED-schijnwerpers, van Philips, die ervoor kunnen zorgen dat er maar liefst twaalf miljoen verschillende kleurencombinaties tevoorschijn kunnen komen. Normaal gesproken is de standaard kleur wit, maar tijdens Independence Day is deze bijvoorbeeld rood, wit en blauw en tijdens de Gay Pride komen de kleuren van de regenboogvlag in beeld.</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Het uitzicht vanaf het Empire State Building\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<span style=\"font-weight: 400;\">Het Empire State Building heeft een adembenemend uitzicht over Manhattan, Brooklyn, en New Jersey. Vanaf de 86e verdieping heb je prachtig zicht op Bryant Park, het Chrysler Building, het Flatiron Building, Midtown en Downtown New York. Central Park is beter zichtbaar vanaf Top of the Rock.</span>[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1620887540936{background-color: #dadada !important;}\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][ultimate_heading main_heading=\"Veelgestelde vragen over het Empire State Building\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:800;\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][vc_toggle title=\"Wat kost een ticket voor het Empire State Building\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]Je hebt tickets vanaf 43 euro. Het Empire zit bij sommige voordeelpassen inbegrepen.[/vc_toggle][vc_toggle title=\"Wat is de beste tijd om het Empire te bezoeken?\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]Met een dag- en nacht ticket heb je de mogelijkheid om New York zowel in daglicht als met lampjes te zien. Anders raden we aan te kiezen voor de vroege morgen. Dan is het nog rustiger op het Empire.[/vc_toggle][vc_toggle title=\"Is het de moeite waard om het Empire te bezoeken?\" custom_font_container=\"tag:h3|font_size:20|text_align:left|line_height:25\" custom_google_fonts=\"font_family:Playfair%20Display%3Aregular%2Citalic%2C700%2C700italic%2C900%2C900italic|font_style:700%20bold%20regular%3A700%3Anormal\" use_custom_heading=\"true\"]Ja, ondanks dat je op andere uitzichtpunten misschien een mooier uitzicht hebt, is het Empire een icoon in de skyline van New York. Alleen daarom is het een bezoek waard.[/vc_toggle][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"80%\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Foto's van Empire State Building\" main_heading_color=\"#b34a4c\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][thb_image_slider images=\"1486,1499,1488,5965\"][vc_empty_space height=\"50px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk in New York City:\" font_container=\"tag:div|font_size:50|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"25px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:1571,1559,-557,-506,10251,10752\"][/vc_column][/vc_row]","post_title":"Tickets Empire State Building","post_link":"https://www.heyusa.com/nl/empire-state-building-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Empire New York\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2021/05/Empire-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Bezienswaardigheden New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1640065446664{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1640065243115{background-color: #ededed !important;}.vc_custom_1620887540936{background-color: #dadada !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}.vc_custom_1586422587255{padding-top: 15px !important;padding-right: 15px !important;padding-bottom: 15px !important;padding-left: 15px !important;}","%_edit_last%":"2","%_edit_lock%":"1706267211:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"14","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_thumbnail_id%":"5965","%standard-featured-credit%":"","%_hide_featured%":null,"%post_source%":[{"title":"Foto credit: Julienne Schaer/NYC & Company","post_source_url":"http://www.nycgo.com"}],"%_yoast_wpseo_focuskw%":"Tickets Empire State Building","%_yoast_wpseo_title%":"Empire State Building in New York bezoeken %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Het Empire State Building in New York is het bezoeken waard. Tips om het Empire State Building te bezoeken en tickets voor het Empire State Building.","%_yoast_wpseo_linkdex%":"73","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"Empire State Building bezoeken\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"Empire State Building, New York, NY 10001, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7485452","%_wpgmp_metabox_longitude%":"-73.98576349999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"7","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1690379384","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_primary_category%":"","taxonomy=category":"Bezienswaardigheden New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png"},"id":1484,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","name":"Bezienswaardigheden","id":"5","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"9/11 Museum","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"9/11 museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/9-11-museum-nyc-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">9/11 Museum</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"180 Greenwich St, New York, NY 10007, Verenigde Staten","location":{"lat":"40.71152649999999","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-74.0123732","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/9-11-museum-memorial-new-york/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"9/11 Museum in New York\" font_container=\"tag:h2|font_size:35|text_align:left|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]<strong>Het 9/11 Museum in New York is de belangrijkste plek in Amerika om de gebeurtenissen van die dag te bekijken en te herinneren. In de kelders van de oorspronkelijk North Tower is sinds 2014 het museum geopend voor bezoekers. Je kunt hier een heleboel attributen zien die te maken hebben met de dag zoals de originele kolommen, een verschroeide ambulance, telefooncellen, een brandweerauto en achtergebleven helmen. In het museum worden de bijna drieduizend mensen herdacht die tijdens de aanlagen van 2001 en 1993 omkwamen. Er zijn grofweg twee exposities: de \u2018historical\u2019 en \u2018memorial\u2019 exhibition. In de eerste kun je de historie zien van 9-11-2001 en de andere herdenkt alle slachtoffers door middel van foto\u2019s en informatie. Het Memorial is buiten het museum en is al sinds 2011 te bezoeken. In totaal zijn er meer dan 10.000 attributen te vinden in het museum en meer dan 2000 interviews te beluisteren.\r\n</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Lower Manhattan | 18 Greenwich Street World Trade Center\"][thb_iconlist icon=\"fas fa-subway\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Fulton Street | A | C | J | 2 | 3 | 4 | 5\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fnational-september-11-memorial-museum-l3394%2F911-memorial-museum-toegang-sla-de-rij-over-t109024%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26cmp%3D911museum|title:9%2F11%20museum%20tickets\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Sta stil bij de gebeurtenissen van 9/11\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Het 9/11 Museum in Lower Manhattan laat je stil staan bij de gebeurtenissen die zich op de bewuste dag in 2001 afspeelden. Een must voor iedereen die zich die dag nog herinnert.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Indrukwekkende verhalen van 9/11\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][heyusa_heading tag=\"h4\" text_align=\"center\" heading=\"Brandweerwagen die gebruikt werd op 9/11\" font_size=\"50\" line_height=\"1\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"776\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Wat mag je niet missen in het 9/11 Museum\" font_container=\"tag:h2|font_size:50|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/3\"][vc_single_image image=\"775\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Voorafgaand aan 9/11\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]In deze tentoonstelling wordt gekeken naar de historische context voorafgaand aan 9/11. Er wordt stil gestaan bij het World Trade Center als een symbool en als doelwit. Er vond in 1993 al een bomaanslag plaats op het World Trade Center. Daarnaast laat het zien hoe het terroristische netwerk rond Al- Qaeda ontwikkelde.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"777\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"9/11\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]In dit gedeelte van het museum vind je een presentatie van de gebeurtenissen die plaats vonden op 9-11. Het geeft je zich in wat er gebeurde toen de vliegtuigen gekaapt werden en in de Twin Towers en het Pentagon vlogen. Alles wat er die dag gebeurde staat centraal in dit deel van het museum, zoals de brandweerwagens, interviews met reddingswerkers, de pilaren van de oude Twin Towers en allerlei voorwerpen die achterbleven na de inslag.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"774\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Na 9/11\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]In de expositie na 9-11-2001 wordt stilgestaan bij de periode na de aanslagen in Amerika. Hoe de wereld reageerde op rouw en de herstelwerkzaamheden en wederopbouw van de <a href=\"https://www.heyusa.com/nl/new-york-city/one-world-trade-center/\" target=\"_blank\" rel=\"noopener noreferrer\">One World Trade Center</a>. Ook zaken als 9-11 gerelateerde ziekten en nationale veiligheid komen hier naar voren.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"250px\"][ultimate_heading main_heading=\"9/11 Memorial\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2F9-11-memorial-new-york%2F|title:9%2F11%20Memorial\" btn_align=\"ubtn-center\" btn_size=\"ubtn-small\" btn_bg_color=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_shadow=\"shd-bottom\" btn_shadow_color=\"#0a0a0a\" btn_shadow_size=\"5\" btn_font_family=\"font_family:Rubik Mono One|font_call:Rubik+Mono+One\" btn_font_size=\"desktop:18px;\"][vc_empty_space height=\"250px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"17086\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"75px\"][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Ontdek andere bezienswaardigheden\" font_size=\"40\" line_height=\"40\" font_color=\"#282828\"][ultimate_heading main_heading=\"In de buurt\" main_heading_color=\"#282828\" main_heading_font_size=\"desktop:40px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:45px;\" margin_design_tab_text=\"\"][/ultimate_heading][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"25px\"][thb_postbackground style=\"style2\" source=\"by_id:-1262,-2267,-572,-545,1571,17083,968,1651\"][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"9/11 Museum","post_link":"https://www.heyusa.com/nl/9-11-museum-memorial-new-york/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"9/11 museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/9-11-museum-nyc-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}","%_edit_lock%":"1691748436:2","%_edit_last%":"2","%_wpb_vc_js_status%":"true","%post-primary-category%":"14","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_wp_old_date%":"2020-06-17","%_yoast_wpseo_focuskw%":"9/11 Museum","%_yoast_wpseo_title%":"%%title%% in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Het 9/11 Museum in New York is een aanrader om te bezoeken. Tips voor je bezoek aan het 9/11 Museum in New York.","%_yoast_wpseo_linkdex%":"75","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"9/11 museum New York\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"180 Greenwich St, New York, NY 10007, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.71152649999999","%_wpgmp_metabox_longitude%":"-74.0123732","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_thumbnail_id%":"10633","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1691748459","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_primary_category%":"","taxonomy=category":"Musea New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":772,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Central Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Central Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/Central-Park-1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Central Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"New York City, New York, Verenigde Staten","location":{"lat":"40.7812199","city":"New York City","state":"New York","country":"Verenigde Staten","lng":"-73.9665138","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/central-park-new-york-city/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"25px\"][vc_custom_heading text=\"Central Park New York - Het groene hart van Manhattan\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Het groene hart van Manhattan. De plek waar locals graag sporten, relaxen of picknicken. Central Park New York is een fijne plek om door heen te wandelen, fietsen of hardlopen. Benieuwd wat je allemaal kunt doen in Central Park? Dit zijn onze tips voor bezienswaardigheden en activiteiten in Central Park.</p>\r\n[/vc_column_text][vc_empty_space height=\"25px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"100%\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Luister naar de\" font_size=\"45\" line_height=\"50\" font_color=\"#b34a4c\"][vc_custom_heading text=\"De New York Podcast\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Aflevering #4: Central Park\" font_container=\"tag:h3|font_size:30|text_align:center|color:%23282828|line_height:1\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:300%20light%20regular%3A300%3Anormal\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][vc_column_text]\r\n<p style=\"text-align: center;\">In deze aflevering van de <strong><a href=\"https://www.heyusa.com/nl/newyork-podcast/\" target=\"_blank\" rel=\"noopener\">New York Podcast</a></strong> praten New York stadsgids Pim, NYC-fan Marjolein en Hey!USA-oprichter Sebastiaan over de achtertuin van Manhattan: \u2060Central Park\u2060. \u00c9\u00e9n van d\u00e9 iconen van New York City. Een gezellige aflevering met klassiekers in het park maar ook de onbekendere plekjes die je absoluut moet bezoeken!</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"25px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][vc_column_text]<iframe src=\"https://podcasters.spotify.com/pod/show/heyusa-newyork-podcast/embed/episodes/Central-Park---De-New-York-Podcast-4-e2kb2gb/a-abamo05\" width=\"100%\" height=\"250px\" frameborder=\"0\" scrolling=\"no\"></iframe>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Central Park\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het stadspark in hartje New York heeft een oppervlakte van ongeveer 350 hectare. Ook wel door New Yorkers \u201cde achtertuin\u201d genoemd, werd in 1858 door architecten Frederick Law Olmsted en Calver Vaux aangelegd. Met miljoenen stenen, zand en aarde werd een voormalig moeras omgetoverd tot het bekendste park ter wereld. Je kunt er rustig kletsen op een bankje langs de verschillende wandelpaden, wandelen naar het beroemde Kasteel van Belvedere of langsgaan bij Strawberry Fields.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Autovrij Central Park\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In het weekend is Central Park voor het grootste gedeelte afgesloten voor verkeer. Dan komen er duizenden mensen joggen, skaten, fietsen en wandelen in het prachtige park. Wil je Central Park volledig bezoeken? Trek er dan zeker een halve dag voor uit.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Veel te doen &amp; zien in Central Park\" font_container=\"tag:h2|font_size:20|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het park heeft meer dan 500.000 struiken en bomen, meerdere weiden, tuinen maar ook speeltuinen, tennisbanen, sportvelden en niet te vergeten de <a href=\"https://www.viator.com/tours/New-York-City/Total-Experience-Tickets/d687-156679P2?pid=P00074479&amp;mcid=42383&amp;medium=link&amp;campaign=centralparkcpzoo\" target=\"_blank\" rel=\"noopener\">Central Park Zo</a>o. Voor een drankje of een snack kun je terecht bij de tientallen kramen langs de paden of de verschillende horeca gelegenheden zoals Loebs Boathouse, het caf\u00e9 bij Conservatory Waters of bijvoorbeeld Tavern on the Green.[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1606168875038{background-color: #eaeaea !important;}\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"1319\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"LENTE &amp; ZOMER\" main_heading_color=\"#000000\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Heerlijke maanden om Central Park in New York te bezoeken. De grasvelden stromen langzaam vol met New Yorkers en toeristen die komen om te relaxen of te sporten. De bootjes van Loebs Boathouse varen weer over The Lake. Wandel over de paden omringd door al het groen en vergeet in de zomermaanden niet om de rollerskaters van Central Park te bezoeken.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"1318\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"WINTER &amp; KERST\" main_heading_color=\"#000000\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Wanneer de bladeren langzaam verkleuren in Central Park weet je dat de herfst weer in aantocht is. Central Park in de herfst is prachtig om door heen te wandelen. In de winter kun je natuurlijk schaatsen bij de Wollman Rink en wie weet heb je geluk en ligt er zelfs sneeuw.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"100%\"][ultimate_heading main_heading=\"Bezienswaardigheden Central Park in New York\" main_heading_color=\"#b34a4c\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][ultimate_heading main_heading=\"Wat kun je allemaal zien in Central Park?\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:300\" main_heading_style=\"font-weight:300;\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"1325\" img_size=\"large\"][ultimate_heading main_heading=\"Wollman Rink\" heading_tag=\"h3\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Deze ijsbaan in Central Park is \u00e9\u00e9n van de mooiste ijsbanen ter wereld. Voor veel New Yorkers is dit dan ook een jaarlijks terugkerende activiteit. Van de herfst tot de lente kun je hier schaatsen. Vanaf de zomer tot eind september maakt de ijsbaan plaats voor de mini-kermis \u201cVictorian Gardens\u201d, dat zich richt op een jong publiek.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"1323\" img_size=\"large\"][ultimate_heading main_heading=\"Strawberry Fields\" heading_tag=\"h3\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Het was op 8 december 1980 om 22u55 dat muzikant John Lennon vlak voor zijn huis in het Dakota Building aan Central Park werd neergeschoten door Mark Chapman. Ter nagedachtenis van deze grote artiest, is er een stukje van Central Park opgedragen aan hem. \u201cStrawberry Fields\u201d (naar het lied Strawberry Fields Forever) is een gedenkplaats geworden voor Lennon.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"6963\" img_size=\"large\"][ultimate_heading main_heading=\"Bow Bridge\" heading_tag=\"h3\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Als er een filmploeg opnames draait in Central Park, dan is de kans groot dan ook Bow Bridge in beeld komt. De brug maakt de verbinding van Cherry Hill naar The Ramble over het meer. Op de gietijzeren brug van zo\u2019n zestig meter lang heb je echt een prachtig uitzicht op het park.[/vc_column_text][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"7094\" img_size=\"large\"][ultimate_heading main_heading=\"Bethesda Fountain\" heading_tag=\"h3\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]De Bethesda Fountain ligt in het hart van Central Park en in het verlengde van The Mall. Vanaf hier kun je genieten van een mooi uitzicht op \u201cThe Lake\u201d en \u201cThe Loeb Boathouse\u201d. De Bethesda Fountain zie je vaak terug in <a href=\"https://www.heyusa.com/nl/inspiratie/new-york-city/filmklassiekers-die-zich-in-new-york-afspelen/\" target=\"_blank\" rel=\"noopener noreferrer\">films</a> en menig trouwfoto en dient als een ontmoetingsplaats in het park. Bijna dagelijks komen er bruidsparen langs om fotoreportages te maken. Het aangrenzende terras, \u201cBethesda Terrace\u201d was \u00e9\u00e9n van de eerste, originele bouwwerken in Central Park en daarmee nog steeds een van de oudste plekjes van het park. Het terras bestaat uit twee verschillende verdiepingen die met elkaar worden verbonden met prachtige trappen. Hier vind je in de zomermaanden ook een publiek toilet.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"7101\" img_size=\"large\"][ultimate_heading main_heading=\"The Mall\" heading_tag=\"h3\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Dit brede pad met een dak van Amerikaanse Iepen en aan weerszijden de bekende Central Park bankjes, is \u00e9\u00e9n van de enige rechte delen van het park. In de 19e eeuw was dit de enige plek waar jonge mannen en vrouwen zonder begeleiding mochten wandelen. Tegenwoordig is het een populaire plek om te zitten, te genieten van de vele park artiesten of een souvenir te kopen. The Mall eindigt bij Bethesda Terrace.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"1316\" img_size=\"large\"][ultimate_heading main_heading=\"Alice in Wonderland Statue\" heading_tag=\"h3\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Het sprookje Alice in Wonderland vind je terug vlakbij het Conservatory Water. Alice wordt omringd door Mad Hatter en White Rabbit. Anders dan de meeste standbeelden, mogen kinderen Alice in Wonderland beklimmen.[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"100%\"][thb_postbackground source=\"post_type:post|by_id:18171\"][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][ultimate_heading main_heading=\"Wat te doen in Central Park New York\" main_heading_color=\"#b34a4c\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][ultimate_heading main_heading=\"Tips voor leuke activiteiten in Central Park\" heading_tag=\"h3\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"1834\" img_size=\"large\"][ultimate_heading main_heading=\"Op de fiets door Central Park\" heading_tag=\"h3\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Het enige wat je moet doen is fietsen! Je ontdekt Central Park helemaal zelf door het park helemaal rond te fietsen. Super leuk op een mooie dag! Ontdek in 2 uur meer van Central Park in New York.[/vc_column_text][ult_buttons btn_title=\"BOEK HIER TICKETS\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.nl%2Fnew-york-l59%2Fcentral-park-fietshuur-t19274%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26cmp%3Dcentralparkfietsen|target:_blank\" btn_align=\"ubtn-center\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"7096\" img_size=\"large\"][ultimate_heading main_heading=\"Met paard en wagen door Central Park\" heading_tag=\"h3\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Net als in de romantische films maak je een rondje door Central Park in een klassieke paardenkoets. Dit kan tijdens alle jaargetijden! In de winter krijg je een lekkere warme deken terwijl de berijder je in geuren en kleuren verteld waar bekende celebrities wonen.\r\nEen ritje duurt ongeveer 45 minuten.[/vc_column_text][ult_buttons btn_title=\"BOEK HIER TICKETS\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fvip-central-park-private-horse-carriage-ride-t400774%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dcentralparkpaardenwagen|target:_blank\" btn_align=\"ubtn-center\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"1833\" img_size=\"large\"][ultimate_heading main_heading=\"Central Park ontdekken met elektrische step\" heading_tag=\"h3\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Genoeg stappen gedaan, maar toch nog graag Central Park ontdekken? Ga mee met de elektrische step tour door Central Park. Onderweg maak je bij verschillende bezienswaardigheden stops en heb je genoeg tijd om foto's te maken. Ondertussen vertelt de gids alles over de locaties waar je stopt.[/vc_column_text][ult_buttons btn_title=\"BOEK HIER TICKETS\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fnew-york-city-central-park-2-hour-electric-scooter-tour-t398155%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dcentralparkelektrischestep|target:_blank\" btn_align=\"ubtn-center\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"13078\" img_size=\"large\" add_caption=\"yes\"][ultimate_heading main_heading=\"Skaten (Skeeleren) in Central Park\" heading_tag=\"h3\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Wil je actief Central Park verkennen en eens op een andere manier dan fietsen of wandelen? Huur dan een paar skeelers en ontdek Central Park op een andere manier. Er zijn verschillende routes waar je uit kunt kiezen. En op skeelers zie je net even wat meer van Central Park dan wandelen in dezelfde tijd![/vc_column_text][ult_buttons btn_title=\"BOEK HIER TICKETS\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fnyc-rollerblade-rental-t60302%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dcentralparkskaten|target:_blank\" btn_align=\"ubtn-center\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"1835\" img_size=\"large\"][ultimate_heading main_heading=\"Hardlopen in Central Park\" heading_tag=\"h3\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Combineer <a href=\"https://www.heyusa.com/nl/hardlopen-in-new-york/\">hardlopen als een New Yorker</a> in Central Park met de grote iconen van het park. Je loopt voorbij Strawberry Fields, de Great Lawn en bijvoorbeeld de Bethesda fontein. Ideaal als je de dag ervoor bij Hard Rock Cafe een stevige hamburger hebt gegeten ;)\r\n\r\nJe zult waarschijnlijk geen persoonlijk record verbreken, maar samen met een \u00e9chte local combineer je sightseeing met sportiviteit! 3. 2. 1. GO!\r\n\r\nDe tour duurt ongeveer 1 uur[/vc_column_text][ult_buttons btn_title=\"BOEK HIER TICKETS\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fcentral-park-l2614%2Fcentral-park-5k-fun-run-t108031%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dcentralparkhardlopen|target:_blank\" btn_align=\"ubtn-center\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_single_image image=\"7097\" img_size=\"large\"][ultimate_heading main_heading=\"Met een Pedicab door Central Park\" heading_tag=\"h3\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]<span style=\"font-weight: 400;\">\u2018Sit back and relax\u2019 terwijl een pedicab zich een ongeluk fietst, zit jij achterin te genieten van een tocht door Central Park. Onderweg vertelt de pedicab fietser alles wat je moet weten over het park, z\u2019n beroemde bewoners en brengt hij je naar de leukste plekjes!</span>[/vc_column_text][ult_buttons btn_title=\"BOEK HIER TICKETS\" btn_link=\"url:https%3A%2F%2Fwww.getyourguide.com%2Fnew-york-city-l59%2Fnew-york-city-private-central-park-pedicab-tour-t346276%2F%3Fpartner_id%3DDMD2VL4%26utm_medium%3Donline_publisher%26placement%3D%2522other%2522%26cmp%3Dcentralparkpedicab|target:_blank\" btn_align=\"ubtn-center\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1678194198432{padding-top: 100px !important;padding-bottom: 100px !important;background-color: #ffffff !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"100%\"][vc_row_inner content_placement=\"middle\"][vc_column_inner width=\"1/2\"][vc_single_image image=\"15148\" img_size=\"large\" onclick=\"custom_link\" img_link_target=\"_blank\" link=\"Oekra\u00efne\"][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_custom_heading text=\"VOORBEREID OP REIS NAAR NEW YORK!\" font_container=\"tag:div|font_size:20|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Roboto%20Slab%3A100%2C300%2Cregular%2C700|font_style:300%20light%20regular%3A300%3Anormal\"][vc_custom_heading text=\"ONTDEK HALLO! NEW YORK &amp; HALLO! BROOKLYN\" font_container=\"tag:div|font_size:30|text_align:left|color:%23000000|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"15px\"][vc_column_text]Klaar om te vertrekken? Ontdek New York als een \u00e9chte New Yorker met onze twee unieke Nederlandstalige New York reisgidsen! Bij elkaar meer dan 800 pagina's inspiratie![/vc_column_text][thb_button link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fwebshop%2Fhallo-reisgidsen%2F|title:Bestel%20een%20reisgids\"][/vc_column_inner][/vc_row_inner][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1640067834403{background-color: #000000 !important;}\"][vc_column][fullwidth_row content_width=\"100%\"][parallax_row opacity=\"85\" image=\"1321\"][vc_empty_space height=\"450px\"][vc_custom_heading text=\"Het groene hart van Manhattan\" font_container=\"tag:h2|font_size:55|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"De longen van New York City\" font_size=\"65\" line_height=\"70\" font_color=\"#ffffff\"][vc_empty_space height=\"450px\"][/vc_column][/vc_row]","post_title":"Central Park","post_link":"https://www.heyusa.com/nl/central-park-new-york-city/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Central Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/Central-Park-1-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Parken New York","post_tags":"","%_edit_last%":"1","%_edit_lock%":"1717170030:1","%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%_hide_featured%":null,"%_thumbnail_id%":"7103","%post_via%":[{"title":"Foto Wollman Rink: Molly Flores / NYC & Company","post_source_url":"nycgo.com"},{"title":"Foto Winter New York: Tagger Yancey IV","post_source_url":"nycgo.com"},{"title":"Foto running: Will Steacy /NYC& Company","post_source_url":"nycgo.com"},{"title":"Foto fietsen: Julienne Schaer/NYC & Company","post_source_url":"nycgo.com"}],"%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"New York Central Park\"]","%inline_featured_image%":"0","%_wpb_shortcodes_custom_css%":".vc_custom_1606168875038{background-color: #eaeaea !important;}.vc_custom_1678194198432{padding-top: 100px !important;padding-bottom: 100px !important;background-color: #ffffff !important;}.vc_custom_1640067834403{background-color: #000000 !important;}","%_yoast_wpseo_focuskw%":"Central Park New York","%_yoast_wpseo_title%":"%%title%% New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Central Park New York is het bekendste park. Benieuwd wat te doen in Central Park? Tips voor bezienswaardigheden in Central Park NYC.","%_yoast_wpseo_linkdex%":"77","%_wpgmp_location_address%":"New York City, New York, Verenigde Staten","%_wpgmp_location_city%":"New York City","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7812199","%_wpgmp_metabox_longitude%":"-73.9665138","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"11","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1717169551","%_yoast_wpseo_wordproof_timestamp%":"","%_last_editor_used_jetpack%":"classic-editor","%_yoast_wpseo_primary_category%":"","%_jetpack_memberships_contains_paid_content%":"","%activeer_submenu%":"0","%_activeer_submenu%":"field_6593f521e97c2","taxonomy=category":"Parken New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/park-icon.png"},"id":1312,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/park-icon.png","name":"Parken","id":"3","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Zion National Park in Utah","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Zion National Park in Utah\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/zion-national-park.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Zion National Park in Utah</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Utah, Verenigde Staten","location":{"lat":"37.2982022","state":"Utah","country":"Verenigde Staten","lng":"-113.0263005","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/zion-national-park-utah/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column width=\"1/2\"][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Zion National Park\" font_container=\"tag:h2|font_size:35|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De vele kleurschakeringen van de rode kliffen, spectaculaire uitzichten en prachtige natuur. Maak je klaar voor een avontuur in \u00e9\u00e9n van de favoriete Nationale Parken van de Verenigde Staten: Zion National Park. Hier vind je letterlijke hoogtepunten, van Angels Landing tot de terrassen van Emerald Pools. Of met je voeten door het water van de Virgin River in de beroemde Zion Narrows. Op deze pagina hebben we alle highlights en must do\u2019s op een rij gezet.[/vc_column_text][ultimate_icon_list icon_size=\"20\"][ultimate_icon_list_item icon=\"Defaults-automobile car\"]258,4km van Las Vegas[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-tree\"]<span class=\"LrzXr kno-fv\">593,3\u00a0km\u00b2 oppervlakte</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-paw\"]<span class=\"LrzXr kno-fv\">386 soorten dieren</span>[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-leaf\"]<span class=\"LrzXr kno-fv\">800 soorten planten</span>[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666519492{background-color: #eaeaea !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"D\u00e9 publiekslieveling\" font_container=\"tag:h2|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Zion National Park is \u00e9\u00e9n van de populairste en meest bezochte parken van West-Amerika. Reizigers roemen het park meestal als favoriet tijdens een rondreis langs de Nationale Parken. Er zijn <a href=\"https://www.heyusa.com/nl/nationale-parken/zion/wandelingen-en-trails/\">verschillende prachtige trails</a>, de natuur is overweldigend mooi en het beste: auto\u2019s zijn hier verboden.</p>\r\n[/vc_column_text][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Zion Lodge\" font_container=\"tag:h2|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Populaire rustplek na een stevige wandeling\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"1279\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Facts Zion NP\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Mukuntuweap National Monument werd al in het jaar 1909 tot Nationaal Park uitgeroepen om de canyon te beschermen. Het park kreeg een nieuwe naam in 1919: Zion National Park.<span class=\"Apple-converted-space\">\u00a0</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Beste reisperiode Zion\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De beste periode om Zion te bezoeken is waarschijnlijk het najaar. De temperaturen zijn nog goed en het is er veel minder druk. Het weer in het voorjaar wil nog wel eens onvoorspelbaar zijn. Tijdens het hoogseizoen (april t/m oktober) zijn auto\u2019s in het gehele natuurreservaat niet toegestaan. Parkeren is gratis aan het begin van het park en de gratis shuttlebussen brengen je naar verschillende haltes in het park.<span class=\"Apple-converted-space\">\u00a0</span>[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Overnachten in Zion NP\" font_container=\"tag:h2|font_size:25|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Zion National Park ligt ongeveer 3 uur rijden van Las Vegas, dit park is dan ook meestal een ideale stop v\u00f3\u00f3r of na een bezoek aan Las Vegas.<span class=\"Apple-converted-space\">\u00a0</span>[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"300px\"][ultimate_heading main_heading=\"Virgin River\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:50px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"De rivier die dwars door Zion kronkelt\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_empty_space height=\"300px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"8171\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner][vc_custom_heading text=\"Hoogtepunten in Zion Canyon NP\" font_container=\"tag:h2|font_size:35|text_align:center|color:%23b34a4c\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Het Nationaal Park ligt grotendeels in de Zion Canyon. Een kloof van 24 kilometer lang en op sommige plekken 800 meter diep. Het ravijn ontstond door de Virgin River, die nog altijd door het park stroomt. Rondom de Virgin River zijn diverse bezienswaardigheden ontstaan die de moeite waard zijn om te bezoeken. Maak een bezoek aan Zion National Park compleet en mis niets van deze hoogtepunten in het park.[/vc_column_text][/vc_column_inner][/vc_row_inner][fullwidth_row content_width=\"90%\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/2\"][fullwidth_row content_width=\"70%\"][vc_custom_heading text=\"Weeping Rock\" font_container=\"tag:h3|font_size:30|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_single_image image=\"8167\" img_size=\"large\"][vc_column_text]Aan de Zion Canyon Scenic Drive ligt Weeping Rock. Om er te komen dien je nog een kleine wandeling te maken voordat je oog in oog staat met een druipende rotswand. De ene keer komt er bijna geen water van de rotswand, de andere keer is het net alsof je onder een waterval doorloopt. Loop ook nog even door naar de voet van Weeping Rock voor een totaaluitzicht.[/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Riverside Walk\" font_container=\"tag:h3|font_size:30|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_single_image image=\"8166\" img_size=\"large\"][vc_column_text]Een verhard pad langs de Virgin River wordt de Riverside Walk genoemd. Een wandelpad van ongeveer 5 kilometer leid je langs rotswanden en watervallen. Vooral in de lente kunnen de watervallen enorm zijn. De Riverside Walk in een overigens ook een goed gebied om wildlife te spotten.[/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/2\"][fullwidth_row content_width=\"70%\"][vc_custom_heading text=\"Lower Emerald Pool\" font_container=\"tag:h3|font_size:30|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_single_image image=\"8163\" img_size=\"large\"][vc_column_text]De Lower Emerald Pool is te bereiken via een trail die je uiteindelijk leidt naar drie verschillende poelen. Het pad begint bij de Zion Lodge en steekt de Virgin River over via een loopbrug. Wanneer je in het juiste seizoen de Lower Emerald Trail gaat lopen, heb je grote kans op diverse watervallen onderweg. De Lower Emerald Pool wordt ook gevuld door zo'n waterval. De poel is niet toegankelijk om in te zwemmen, maar de mist van de watervallen zorgt af en toe wel voor verkoeling op warme dagen.[/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Angel's Landing\" font_container=\"tag:h3|font_size:30|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_single_image image=\"8161\" img_size=\"large\"][vc_column_text]Een van de meest bekende en populaire wandeling in Zion National Park is Angel's Landing. Het is een pittige wandeling van ongeveer 7 \u00e0 8 kilometer waarbij flink geklommen en gedaald wordt. Via steile kliffen en haarspeldbochten bereik je hoogtes waar mensen met hoogtevrees beter niet kunnen komen. Het laatste deel van de route, na de Scout Lookout, is dan ook niet geschikt voor mensen met hoogtevrees. Je loopt via een pad met kettingen naar het einde van Angel's Landing. Zwaar, maar de uitzichten onderweg zijn het zeker waard.[/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/2\"][fullwidth_row content_width=\"70%\"][vc_custom_heading text=\"The Narrows\" font_container=\"tag:h3|font_size:30|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_single_image image=\"8164\" img_size=\"large\"][vc_column_text]Een andere populaire plek in Zion National Park is The Narrows, het smalste deel van Zion Canyon. Wandelen door de kloof van The Narrows is een iconische wandeling in Zion, de Virgin River stroomt dwars door de canyon waardoor natte voeten gegarandeerd zijn. De totale wandeling is ongeveer 16 kilometer heen en terug, natuurlijk kun je ook besluiten om eerder terug te gaan. Trek voor de gehele wandeling in ieder geval de hele dag uit. Ook is het goed om je van te voren te laten informeren over de <a href=\"https://www.nps.gov/zion/planyourvisit/conditions.htm\" target=\"_blank\" rel=\"noopener\">omstandigheden</a>. Flash Floods komen regelmatig voor, dus de wandeling is niet zonder gevaar.[/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Scenic Drive\" font_container=\"tag:h3|font_size:30|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_single_image image=\"8170\" img_size=\"large\"][vc_column_text]Zion kun je ook vanuit de auto zien op De Zion Canyon Scenic Drive. Door de drukte is de weg alleen in de winter zelf te rijden, in de andere perioden kun je de shuttle bus pakken. De route loopt vanaf het bezoekerscentrum naar de tempel van Sinawava. Onderweg heb je de mogelijkheid om bij de vele hoogtepunten van Zion te stoppen.[/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row][vc_column width=\"1/2\"][fullwidth_row content_width=\"70%\"][vc_custom_heading text=\"Observation Point\" font_container=\"tag:h3|font_size:30|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_single_image image=\"8165\" img_size=\"large\"][vc_column_text]Observation Point in Zion National Park, op een hoogte van 2000 meter, geeft je een panoramisch uitzicht over de canyon. Ook de trail van Angel's Landing is vanaf hier goed te zien. Om bij Observation Point te komen, is er een wandelpad van ongeveer 12 kilometer (heen en terug) die je kunt volgen. De stijgingen bij deze trail zijn redelijk, dus houdt rekening met de omstandigheden.[/vc_column_text][/vc_column][vc_column width=\"1/2\"][vc_custom_heading text=\"Checkboard Mesa\" font_container=\"tag:h3|font_size:30|text_align:left\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_single_image image=\"8162\" img_size=\"large\"][vc_column_text]Net buiten het park, bij de oostelijk ingang, vind je dit geologische hoogtepunt: Checkboard Mesa. De witgekleurde mesa valt op vanwege het dambordpatroon op de rotsformatie. Je kunt een stop maken op de parkeerplaats en het landschap verder verkennen via \u00e9\u00e9n van de wandelingen. De oostelijke kant van het park verschilt van de westelijke kant met een landschap van berghellingen van witte steen en daarop pijnbomen.[/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"75px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Zion Canyon\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"24 kilometer lang en 800 meter diep\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"1290\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Wandelingen &amp; trails\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_column_text]Je kunt het Zion National Park verkennen via verschillende wandelingen en trails door het park. Er zijn trails voor waaghalzen, zoals <strong>Angels Landing</strong>. Maar ook voor de minder fanatieke wandelaar zijn er prachtige wandelingen, zoals de <strong>Emerald Pools Trail</strong>, de <strong>Weeping Rock trail</strong> en de <strong>Watchman</strong>. De <strong>Zion Lodge</strong> is een populaire plek voor of na een wandeling en je kunt hier ook overnachten.[/vc_column_text][ultimate_heading main_heading=\"Favoriete wandeling in Zion\" heading_tag=\"h3\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:20px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:25px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][vc_column_text]De bekendste en favoriete trail, is <strong>The Narrows</strong>. Tijdens deze wandeling, wandel je door de Virgin River in de smalle Zion Narrows Canyon. De volledige route is 15km lang, maar al een kilometer met je voeten door het water, is een belevenis.[/vc_column_text][ult_buttons btn_title=\"Wandelingen in Zion\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fnationale-parken%2Fzion%2Fwandelingen-en-trails%2F|title:Wandelingen%20in%20Zion|target:_blank\" btn_size=\"ubtn-mini\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_bg_color_hover=\"#531a23\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:20px;\"][ult_buttons btn_title=\"Wandelingen in Zion\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fnationale-parken%2Fzion%2Fwandelingen-en-trails%2F|title:Wandelingen%20in%20Zion\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#dd3333\" btn_hover=\"ubtn-bottom-bg\" btn_bg_color_hover=\"#000000\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Rubik Mono One|font_call:Rubik+Mono+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"Handige info voor je bezoek\" main_heading_color=\"#000000\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:800\" main_heading_line_height=\"desktop:55px;\" main_heading_style=\"font-weight:800;\"][/ultimate_heading][ultimate_icon_list icon_size=\"25\"][ultimate_icon_list_item icon=\"Defaults-clock-o\" content_font_size=\"desktop:16px;\"]24/7 en 365 dagen geopend[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-thumbs-up\" content_font_size=\"desktop:16px;\"]Beste periode: Eind september / oktober[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-dollar usd\" content_font_size=\"desktop:16px;\"]7-daagse toegang met auto of camper: $25[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-ticket\" content_font_size=\"desktop:16px;\"]$12 per persoon[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-location-arrow\" content_font_size=\"desktop:16px;\"]15 wandelingen[/ultimate_icon_list_item][ultimate_icon_list_item icon=\"Defaults-bed hotel\" content_font_size=\"desktop:16px;\"]5 backpacking trails[/ultimate_icon_list_item][/ultimate_icon_list][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1582906882917{padding-top: 25px !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Zion Narrow Canyon\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:45px;\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_line_height=\"desktop:55px;\"][/ultimate_heading][vc_empty_space height=\"10px\"][ultimate_heading main_heading=\"Populaire wandeling door de Virgin River\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:25px;\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab|variant:900\" main_heading_line_height=\"desktop:30px;\" main_heading_style=\"font-weight:900;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row enable_mobile=\"parallax-enable-mobile\" image=\"1304\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][vc_custom_heading text=\"Meer over Zion:\" font_container=\"tag:div|font_size:40|text_align:center\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][thb_postgrid style=\"style11\" columns=\"4\" source=\"post_type:post|by_id:1350\"][/vc_column][/vc_row]","post_title":"Zion National Park in Utah","post_link":"https://www.heyusa.com/nl/zion-national-park-utah/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Zion National Park in Utah\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/08/zion-national-park.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Zion National Park","post_tags":"Utah","%_edit_lock%":"1676889489:2","%_edit_last%":"1","%_thumbnail_id%":"1274","%_hide_featured%":null,"%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style11","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%_wpb_shortcodes_custom_css%":".vc_custom_1608666519492{background-color: #eaeaea !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1582906882917{padding-top: 25px !important;}.vc_custom_1608666885497{background-image: url(https://www.heyusa.com/nl/wp-content/uploads/2020/08/background-heyusa-natuur-1.gif?id=3088) !important;}.vc_custom_1582906882917{padding-top: 25px !important;}","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_yoast_wpseo_focuskw%":"Zion National Park","%_yoast_wpseo_metadesc%":"Zion National Park in de Amerikaanse staat Utah is een van de meest bezochte parken in Amerika. Tips voor je bezoek aan Zion National Park","%_yoast_wpseo_linkdex%":"82","%_wpgmp_location_address%":"Utah, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Utah","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"37.2982022","%_wpgmp_metabox_longitude%":"-113.0263005","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"7","%thb-reactions-votes%":"1","%_last_editor_used_jetpack%":"classic-editor","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_indexnow_last_ping%":"1677015551","taxonomy=category":"Zion National Park","taxonomy=post_tag":"Utah","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png"},"id":1273,"infowindow_disable":false},{"source":"post","title":"NYC Transit Museum","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"NYC Transit Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/06/transit-museum4-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">NYC Transit Museum</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"99 Schermerhorn St, Brooklyn, NY 11201, Verenigde Staten","location":{"lat":"40.6903933","state":"New York","country":"Verenigde Staten","lng":"-73.98984","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/nyc-transit-museum/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][fullwidth_row content_width=\"90%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_column_text]\r\n\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][ultimate_heading main_heading=\"NYC Transit Museum in New York\"][/ultimate_heading][vc_column_text]<strong>Dompel je onder in de geschiedenis van het openbaar vervoer in New York. Alles wat je wilt weten over de metro en de bus vind je in het New York Transit Museum in Brooklyn. In een oud metrostation op Court Street in Downtown Brooklyn zit het hoofdgebouw van het museum, een kleinere vestiging vind je in Grand Central Terminal in Midtown Manhattan. Het station is gebruikt voor meerdere <a href=\"https://www.heyusa.com/nl/inspiratie/new-york-city/filmklassiekers-die-zich-in-new-york-afspelen/\" target=\"_blank\" rel=\"noopener noreferrer\">filmsettings</a>, de meest bekende en recente, voordat het een museum werd, was Taking of Pelham 123 uit 1974.</strong>[/vc_column_text][thb_iconlist icon=\"fas fa-map-marker-alt\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Brooklyn | 99 Schermerhorn Street\"][thb_iconlist icon=\"fas fa-subway\" thb_icon_color=\"#000000\" thb_text_color=\"#000000\" list_content=\"Borough Hall | 4 | 5\"][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"Bestel je tickets\" btn_link=\"url:https%3A%2F%2Fwww.nytransitmuseum.org%2F|title:Bestel%20je%20tickets\" btn_size=\"ubtn-large\" btn_title_color=\"#ffffff\" btn_bg_color=\"#b34a4c\" btn_hover=\"ubtn-left-bg\" btn_bg_color_hover=\"#531a23\" btn_title_color_hover=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" btn_font_size=\"desktop:15px;\"][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" css=\".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}\"][vc_column width=\"1/6\"][/vc_column][vc_column width=\"2/3\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"50px\"][ultimate_heading main_heading=\"Duik in de geschiedenis van het openbaar vervoer van New York\" main_heading_color=\"#282828\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:35px;\" main_heading_line_height=\"desktop:40px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In het oude metrostation in Brooklyn leer je alles over het openbaar vervoer van New York. Wandel door oude metrowagons onder de grond in Brooklyn. Het NYC Transit Museum is een aanrader voor iedere doelgroep.</p>\r\n[/vc_column_text][/vc_column][vc_column width=\"1/6\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][ultimate_heading main_heading=\"Vintage metrowagens\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_font_size=\"desktop:55px;\" main_heading_line_height=\"desktop:60px;\"][/ultimate_heading][ultimate_heading main_heading=\"Leuke collectie van diverse oude wagons die gebruikt werden in NYC\" heading_tag=\"p\" main_heading_color=\"#ffffff\" main_heading_font_family=\"font_family:Dancing Script|font_call:Dancing+Script|variant:700\" main_heading_font_size=\"desktop:45px;\" main_heading_line_height=\"desktop:50px;\" main_heading_style=\"font-weight:700;\"][/ultimate_heading][vc_empty_space height=\"350px\"][parallax_row opacity=\"85\" enable_mobile=\"parallax-enable-mobile\" image=\"8015\"][/vc_column][/vc_row][vc_row css=\".vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}\"][vc_column][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"75px\"][vc_custom_heading text=\"Wat mag je niet missen in het Transit Museum\" font_container=\"tag:h2|font_size:50|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"75px\"][vc_row_inner css=\".vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}\"][vc_column_inner width=\"1/4\"][vc_single_image image=\"8016\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Vintage metrostations\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Pronkstukken van het museum zijn toch wel de oude metrowagons die je nog kunt zien. Van houten wagons die reden vanaf 1908 in New York tot designs van net na de Tweede Wereldoorlog. Houten wagons die na een brand uiteindelijk verboden werden en door de toename van de passagiersstroom na de Tweede Wereldoorlog, werden de wagons moderner. Zo\u2019n zeven verschillende wagons zijn nog bewonderen in het NYC Transit Museum en het is leuk om te zien hoe ze in al die jaren veranderd zijn.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][vc_single_image image=\"8019\" img_size=\"large\" add_caption=\"yes\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Vintage bussen\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]Net als oude metrowagons zijn er ook vintage bussen te bewonderen in het museum. Pure nostalgie wanneer je bussen uit de jaren \u201950 van de vorige eeuw ziet staan. De oudste bus komt uit 1948 en werd nog gebruikt in de televisieserie The Honeymooners. Ook de eerste bus die met airco rond reed kun je bekijken in het museum.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/4\"][vc_single_image image=\"8020\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"Exposities\" heading_tag=\"h3\" alignment=\"left\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]In het museum zijn veel (tijdelijke) tentoonstellingen te bekijken. Zo kun je onder andere een tentoonstelling bekijken over het ontstaan van het openbaar vervoer in New York. Kaarten laten zien hoe het systeem ontstaan en gegroeid is in al die jaren. In een andere tentoonstelling kun je de geschiedenis van het ticket voorbij zien komen. Welke vervoersbewijzen werden er door de jaren heen gebruikt.[/vc_column_text][/vc_column_inner][vc_column_inner thb_color=\"thb-light-column\" width=\"1/4\" css=\".vc_custom_1625324880871{padding-top: 25px !important;padding-right: 25px !important;padding-bottom: 25px !important;padding-left: 25px !important;background-color: #b34a4c !important;}\"][vc_widget_sidebar sidebar_id=\"ca-sidebar-5228\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"250px\"][ultimate_heading main_heading=\"BROOKLYN HEIGHTS\" heading_tag=\"p\" main_heading_color=\"#ffffff\" sub_heading_color=\"#ffffff\" main_heading_font_size=\"desktop:55px;\" main_heading_font_family=\"font_family:Arvo|font_call:Arvo|variant:700italic\" main_heading_line_height=\"desktop:45px;\" sub_heading_font_family=\"font_family:Rubik Mono One|font_call:Rubik+Mono+One\" sub_heading_font_size=\"desktop:20px;\" main_heading_style=\"font-style:italic;font-weight:700;\"]Ontdek de wijk waar het Transit Museum ligt[/ultimate_heading][vc_empty_space height=\"25px\"][ult_buttons btn_title=\"LEES MEER\" btn_link=\"url:https%3A%2F%2Fwww.heyusa.com%2Fnl%2Fnew-york%2Fbrooklyn-heights%2F|title:Brooklyn%20Heights\" btn_align=\"ubtn-center\" btn_size=\"ubtn-small\" btn_bg_color=\"#ffffff\" icon_size=\"32\" btn_icon_pos=\"ubtn-sep-icon-at-left\" btn_shadow=\"shd-bottom\" btn_shadow_color=\"#0a0a0a\" btn_shadow_size=\"5\" btn_font_family=\"font_family:Rubik Mono One|font_call:Rubik+Mono+One\" btn_font_size=\"desktop:18px;\"][vc_empty_space height=\"250px\"][parallax_row opacity=\"80\" enable_mobile=\"parallax-enable-mobile\" image=\"8025\"][/vc_column][/vc_row][vc_row][vc_column][/vc_column][/vc_row]","post_title":"NYC Transit Museum","post_link":"https://www.heyusa.com/nl/nyc-transit-museum/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"NYC Transit Museum\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/06/transit-museum4-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Musea New York","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1582906241940{padding-top: 50px !important;padding-bottom: 50px !important;background-color: #e2e2e2 !important;}.vc_custom_1587659299071{padding-top: 25px !important;background-color: #000000 !important;}.vc_custom_1472307502290{padding-top: 25px !important;padding-bottom: 25px !important;}.vc_custom_1583007716507{padding-top: 25px !important;background-color: #0a0a0a !important;}.vc_custom_1582970704903{padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;}.vc_custom_1625324880871{padding-top: 25px !important;padding-right: 25px !important;padding-bottom: 25px !important;padding-left: 25px !important;background-color: #b34a4c !important;}","%_edit_lock%":"1649336305:2","%_edit_last%":"1","%_wpb_vc_js_status%":"true","%post-primary-category%":"16","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%executive_summary%":"","%thb-reactions-votes%":"1","%_hide_featured%":null,"%_yoast_wpseo_focuskw%":"NYC Transit Museum in New York","%_yoast_wpseo_title%":"%%title%% in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_linkdex%":"65","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%_yoast_wpseo_metadesc%":"Het NYC Transit Museum in New York is een aanrader voor jong en oud. Leer in het Transit Museum alles over het openbaar vervoer in New York.","%inline_featured_image%":"0","%_wpgmp_location_address%":"99 Schermerhorn St, Brooklyn, NY 11201, Verenigde Staten","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.6903933","%_wpgmp_metabox_longitude%":"-73.98984","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_thumbnail_id%":"8018","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_indexnow_last_ping%":"1677015556","taxonomy=category":"Musea New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png"},"id":782,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","name":"Musea","id":"2","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Battery Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Battery Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/06/Battery-Park-NYC-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Battery Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Battery Park City, New York City, New York 10004, Verenigde Staten","location":{"lat":"40.703141","city":"New York City","state":"New York","country":"Verenigde Staten","lng":"-74.0159996","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/battery-park-new-york-city/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"25px\"][vc_custom_heading text=\"Battery Park in New York\" font_container=\"tag:h2|font_size:45|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Zuidelijkste park van Manhattan\" font_container=\"tag:p|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"100px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Nederlandse roots\" font_container=\"tag:h2|font_size:25|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Gelegen in het zuidelijkste puntje van<a href=\"https://www.heyusa.com/nl/newyork/newyorkcity/buurten/lower-manhattan/\" target=\"_blank\" rel=\"noopener noreferrer\"> Lower Manhattan</a>, heeft dit park vooral Nederlandse roots. Battery Park stamt uit de kolonisatie van de Nederlanders en verwijst naar een batterij kanonnen, die daar stonden opgesteld. Het park ligt aan de oever van de Hudson en is de thuishaven van de \u201cLiberty Cruises\u201d en de <a href=\"https://www.heyusa.com/nl/new-york-city/staten-island-ferry/\" target=\"_blank\" rel=\"noopener noreferrer\">Staten Island Ferry</a>. Het 19e eeuwse Castle Clinton was het fort van de Britten tijdens de Britse overheersing. Oorspronkelijk lag het fort op een kunstmatig eiland dichtbij Manhattan, maar door de landwinning van Manhattan kwam het eiland op het vaste land te liggen.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Castle Clinton\" font_container=\"tag:h2|font_size:25|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Vernoemd naar burgemeester DeWitt Clinton (burgemeester van 1803 tot en met 1807) heeft Castle Clinton meerdere bestemmingen gehad. Van promenade tot biergarten en van theater tot aquarium. Tegenwoordig hoort Castle Clinton onder de verantwoordelijk van de National Park Service. Er zijn regelmatig kleine concerten tijdens de zomer, een klein museum en de <a href=\"https://www.nps.gov/stli/index.htm\" target=\"_blank\" rel=\"noopener noreferrer\">ticketverkoop</a> van het Vrijheidsbeeld te vinden.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Oude stadsmuur\" font_container=\"tag:h2|font_size:25|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]In het metrostation South Ferry vind je een stukje oud Nederlandse historie in New York: Een stadsmuur. Dit typische Europese fenomeen werd in 2005 ontdekt tijdens de verbouwing van de Staten Island Terminal. De 200 jarige muur, onderdeel van in totaal vier muren, werd bewaard en tentoongesteld op dezelfde diepte en plaats waar de muur ontdekt werd.[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"100%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"11156\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"LENTE &amp; ZOMER\" heading_tag=\"p\" main_heading_color=\"#000000\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:25px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Battery Park is in ieder jaargetijde een drukke plek. Dit heeft te maken met het feit dat de Staten Island Ferry vertrekt vanaf het zuidelijkste puntje van Manhattan. In de zomermaanden is Battery Park dan ook vol met locals en toeristen. Daarnaast is het park vaak het decor voor films en televisieseries.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"5401\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"WINTER &amp; KERST\" heading_tag=\"p\" main_heading_color=\"#000000\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\" main_heading_line_height=\"desktop:25px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Ook in de koudere maanden tref je genoeg mensen aan in Battery Park. Het park is sfeervol in de decembermaand en er lopen bijna altijd wel mensen. Battery Park blijft door Castle Clinton, het uitzicht en de ferry naar het Vrijheidsbeeld een populaire plek.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" content_placement=\"middle\" full_width=\"stretch_row\" content_text_aligment=\"center\" css=\".vc_custom_1633532389694{padding-top: 25px !important;background-color: #000000 !important;}\" parallax_background_image=\"3836\"][vc_column thb_color=\"thb-light-column\"][fullwidth_row content_width=\"90%\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"Uitzicht op Lady Liberty\" font_container=\"tag:div|font_size:75|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Het Zuidelijkste puntje van Manhattan\" font_container=\"tag:div|font_size:45|text_align:center|color:%23ffffff\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][vc_empty_space height=\"350px\"][parallax_row opacity=\"90\" enable_mobile=\"parallax-enable-mobile\" image=\"672\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York\" font_container=\"tag:div|font_size:50|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:968,1733,1571,772\"][/vc_column][/vc_row]","post_title":"Battery Park","post_link":"https://www.heyusa.com/nl/battery-park-new-york-city/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Battery Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/06/Battery-Park-NYC-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Parken New York","post_tags":"","%_edit_last%":"1","%_edit_lock%":"1667479029:2","%_wpb_vc_js_status%":"true","%post-primary-category%":"13","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%_hide_featured%":null,"%_yoast_wpseo_focuskw%":"Battery Park in New York","%_yoast_wpseo_title%":"%%title%% in New York %%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Battery Park in New York in het zuidelijkste puntje van Manhattan is een fijn park om te wandelen. Tips voor je bezoek aan Battery Park?","%_yoast_wpseo_linkdex%":"73","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"Battery Park City, New York City, New York 10004, Verenigde Staten","%_wpgmp_location_city%":"New York City","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.703141","%_wpgmp_metabox_longitude%":"-74.0159996","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_thumbnail_id%":"5402","%_wpb_shortcodes_custom_css%":".vc_custom_1633532389694{padding-top: 25px !important;background-color: #000000 !important;}","%_yoast_indexnow_last_ping%":"1677015561","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Parken New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/park-icon.png"},"id":667,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/park-icon.png","name":"Parken","id":"3","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"The High Line","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The High Line\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/06/The-High-Line-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">The High Line</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"New York City, New York 10011, Verenigde Staten","location":{"lat":"40.7479925","city":"New York City","state":"New York","country":"Verenigde Staten","lng":"-74.0047649","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/the-high-line-new-york-city/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"25px\"][vc_custom_heading text=\"The High Line in New York\" font_container=\"tag:h2|font_size:45|text_align:center|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_custom_heading text=\"Wandel over een oude spoorlijn 8 meter boven de grond\" font_container=\"tag:p|font_size:35|text_align:center|line_height:1\" google_fonts=\"font_family:Dancing%20Script%3Aregular%2C700|font_style:700%20bold%20regular%3A700%3Anormal\"][ultimate_video u_video_url=\"https://www.youtube.com/watch?v=Wud-8MJC0p0\" yt_autoplay=\"\" yt_sugg_video=\"\" yt_mute_control=\"\" yt_modest_branding=\"\" yt_privacy_mode=\"\" play_size=\"75\" enable_sub_bar=\"\"][vc_empty_space height=\"100px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Opleving van de buurten\" font_container=\"tag:h2|font_size:25|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De komst van The High Line zorgde voor een opleving van de buurten direct gelegen aan het nieuwe park. Diverse nieuwe en architectonisch bijzondere gebouwen, appartementen en The Standard Hotel maakten van Chelsea een zeer gewilde buurt om te wonen en werken. De komst van Chelsea Market zorgde voor een ware hype en het nieuwe <a href=\"https://www.heyusa.com/nl/new-york-city/whitney-museum-of-american-art/\" target=\"_blank\" rel=\"noopener noreferrer\">Whitney Museum</a> bracht de wijk een lang gekoesterd museum.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Oude spoorlijn\" font_container=\"tag:h2|font_size:25|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Met bijna 2,5 kilometer lang van <a href=\"https://www.heyusa.com/nl/new-york/chelsea/\" target=\"_blank\" rel=\"noopener noreferrer\">Chelsea</a> naar <a href=\"https://www.heyusa.com/nl/new-york/hudson-yards/\" target=\"_blank\" rel=\"noopener noreferrer\">Hudson Yards</a>, is The High Line verreweg het meest bijzondere park van New York. Bijzonder omdat het park 8 meter boven de grond loopt op het voormalige spoor van de West Side Line van het New Yorkse Central Railroad.Het eerste en meest Zuidelijke deel van The High Line werd geopend op 8 juni 2009 en begon vanaf Gansevoort Street tot 20th Street. In 2011 werd het tweede deel toegevoegd aan het park waarmee het werd verlengt naar 30th Street. Drie jaar later, na onderhandelingen met de voormalige eigenaar van het Noordelijke deel, werd het derde en voorlaatste deel van The High Line geopend. Inmiddels loopt The High Line door tot aan de nieuwste wijk van New York: Hudson Yards.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Wandel langs diverse kunstwerken\" font_container=\"tag:h2|font_size:25|text_align:left|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Diverse kunstwerken sieren de wandelroute op The High Line. Op meer dan tien plekken zie je onderweg verschillende kunstwerken. Op twee plekken kun je zelfs nog Kobra Murals zien vanaf The High Line. Op de kruising met 10th avenue vind je een uitzichtpunt vanwaar je over de straat kunt kijken. In een soort amfitheater kijk je over de rijdende auto\u2019s onder je. Ook aan het einde van The High Line bij Hudson Yards heb je tegenwoordig een fijn plein vanwaar je een mooi uitzicht hebt en diverse kunstwerken staan.[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"662\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"LENTE &amp; ZOMER\" heading_tag=\"p\" main_heading_color=\"#000000\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Hoewel je The High Line het gehele jaar kunt bezoeken, zijn de zomermaanden toch wel favoriet. Het is dan ook echt een stuk drukker op de wandelroute. Gelukkig zijn er onderweg genoeg mogelijkheden om even in de schaduw te zitten of ergens iets te eten of drinken te kopen.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"5407\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"WINTER &amp; KERST\" heading_tag=\"p\" main_heading_color=\"#000000\" main_heading_font_family=\"font_family:Alfa Slab One|font_call:Alfa+Slab+One\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\" margin_design_tab_text=\"\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">In de koudere maanden is het minder druk op The High Line. Toch kun je prima een wandeling maken. Van te voren lunchen of ontbijten bij Chelsea Market en weer opwarmen in de Mercado Little Spain Foodhall in Hudson Yards.</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][thb_image_slider autoplay=\"true\" images=\"86,5407,1015,947,838,7112,662,526,663\"][/vc_column][/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"90%\"][vc_custom_heading text=\"Ook leuk om te doen in New York\" font_container=\"tag:div|font_size:50|text_align:center|color:%23000000\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"50px\"][thb_postgrid style=\"style20\" columns=\"4\" source=\"post_type:post|by_id:1759,520,1484,3408\"][/vc_column][/vc_row]","post_title":"The High Line","post_link":"https://www.heyusa.com/nl/the-high-line-new-york-city/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The High Line\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/06/The-High-Line-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Parken New York","post_tags":"","%_edit_last%":"1","%_edit_lock%":"1633528669:1","%_wpb_vc_js_status%":"true","%post-primary-category%":"13","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%_hide_featured%":null,"%_yoast_wpseo_focuskw%":"The High Line in New York","%_yoast_wpseo_title%":"%%title%% in New York%%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Een van de leukste parken in New York is The High Line. Wandel over de oude spoorlijn van Chelsea naar Hudson Yards over The High Line.","%_yoast_wpseo_linkdex%":"68","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"New York City, New York 10011, Verenigde Staten","%_wpgmp_location_city%":"New York City","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7479925","%_wpgmp_metabox_longitude%":"-74.0047649","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_thumbnail_id%":"7112","%_yoast_indexnow_last_ping%":"1677015563","taxonomy=category":"Parken New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/park-icon.png"},"id":661,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/park-icon.png","name":"Parken","id":"3","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Washington Square Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Washington Square Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/03/Washington-square-park-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">Washington Square Park</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>","address":"Washington Square, New York, NY 10012, Verenigde Staten","location":{"lat":"40.7308838","city":"New York","state":"New York","country":"Verenigde Staten","lng":"-73.997332","onclick_action":"marker","redirect_permalink":"https://www.heyusa.com/nl/washington-square-park-new-york-city/","zoom":12,"extra_fields":{"post_excerpt":"","post_content":"[vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"25px\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Hier begint Fifth Avenue\" font_size=\"55\" line_height=\"60\" font_color=\"#282828\"][vc_custom_heading text=\"Washington Square Park in New York\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][vc_column_text]\r\n<p style=\"text-align: center;\">Washington Square Park in de wijk <a href=\"https://www.heyusa.com/nl/new-york/greenwich-village/\" target=\"_blank\" rel=\"noopener\">Greenwich Village</a> is \u00e9\u00e9n van die typische New Yorkse plekjes waar iedereen enthousiast over wordt. Het park ligt aan het beginpunt van het prestigieuze Fifth Avenue \u00e9n is het centrum van NYU, de New York University.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"100px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1721555005330{background-color: #000000 !important;}\"][vc_column][fullwidth_row content_width=\"100%\"][parallax_row opacity=\"90\" image=\"20240\"][vc_empty_space height=\"350px\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Het Empire State Building\" font_size=\"65\" line_height=\"70\" font_color=\"#ffffff\"][vc_custom_heading text=\"Door de triomfboog van George Washington\" font_container=\"tag:h2|font_size:65|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"350px\"][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"100%\"][vc_row_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Nieuw Amsterdam\" font_container=\"tag:h3|font_size:25|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Tijdens Nieuw Amsterdam was het huidige Washington Square Park in New York vooral bekend als de buurt waar \u201cbevrijde\u201d slaven mochten wonen en werken als boeren. Hoewel ze officieel geen slaaf meer waren, dienden ze als een schild tussen de Nederlanders en de Indianen.\r\nDe snel groeiende stad kocht in 1779 de grond om een algemene begraafplaats in te richten. Tot op de dag van vandaag liggen circa 20.000 lichamen, als gevolg van de gele griep, nog steeds onder het huidige park.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"Militair grondgebied\" font_container=\"tag:h3|font_size:25|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]Rond 1830 werd de begraafplaats vervangen om te dienen als militair grondgebied voor parades en publieke executies. Rond 1849, mede door de komst van de rijke elite, werd het militair terrein al snel tot park verbouwd. Het gebied rondom het huidige Washington Square was een aantrekkelijke plek geworden waar dure en grote huizen werden gebouwd.[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/3\"][vc_custom_heading text=\"'De Arc de Triomphe'\" font_container=\"tag:h3|font_size:25|text_align:left|color:%23282828|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]De beroemde \u201cStanford White Arch\u201d op het plein, wordt door menig toerist ook wel de \u201cArc de Triomph van New York\u201d genoemd, verwijzend naar de grotere versie in Parijs. De eerste en originele boog werd in 1889 gebouwd van hout ter ere van de eerste president van de Verenigde Staten: George Washington. De populaire boog werd vervolgens in 1885, zes jaar later, vervangen voor het huidige exemplaar. Wanneer je onder de Arch doorkijkt zie je het <a href=\"https://www.heyusa.com/nl/new-york-city/empire-state-building/\" target=\"_blank\" rel=\"noopener noreferrer\">Empire State Building</a> in de verte liggen.[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][fullwidth_row content_width=\"100%\"][vc_column_text][/vc_column_text][/vc_column][/vc_row][vc_row thb_full_width=\"true\"][vc_column][vc_empty_space height=\"50px\"][fullwidth_row content_width=\"100%\"][vc_row_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"158\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"LENTE &amp; ZOMER\" heading_tag=\"p\" main_heading_color=\"#000000\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Washington Square Park is een heerlijk tafereel om te bekijk in de zomermaanden. De fonteinen staan aan, kinderen spelen in het water en er heerst een gezellige drukte. Eind augustus verwelkomt NYU, de New York University de nieuwe studenten in de studentenkamers van de campus. Je ziet dan honderden studenten met hun ouders verhuizen.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_single_image image=\"156\" img_size=\"large\" alignment=\"center\" style=\"vc_box_shadow_3d\"][ultimate_heading main_heading=\"WINTER &amp; KERST\" heading_tag=\"p\" main_heading_color=\"#000000\" main_heading_font_family=\"font_family:Roboto Slab|font_call:Roboto+Slab\" main_heading_style=\"font-weight:700;\" main_heading_font_size=\"desktop:25px;\"][/ultimate_heading][vc_column_text]\r\n<p style=\"text-align: center;\">Tijdens de kerstperiode is Washington Square Park \u00e9\u00e9n van de parken in New York City waar je een verlichte kerstboom kunt vinden. Bijzonder is vooral de positie, precies in het midden voor de triomboog. Een \u00e9cht Instagram-momentje!</p>\r\n[/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1721555005330{background-color: #000000 !important;}\"][vc_column][fullwidth_row content_width=\"100%\"][parallax_row opacity=\"90\" image=\"160\"][vc_empty_space height=\"350px\"][vc_custom_heading text=\"De achtertuin van NYU\" font_container=\"tag:h2|font_size:65|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"New York University\" font_size=\"65\" line_height=\"70\" font_color=\"#ffffff\"][vc_empty_space height=\"350px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"95%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Uniek moment in Washington Square Park\" font_size=\"50\" line_height=\"55\" font_color=\"#282828\"][vc_custom_heading text=\"De veerkracht van Amerika tijdens een regenbui in Washington Square Park\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][thb_iconbox type=\"left type1\" animation=\"\" icon_image=\"19695\" icon_image_width=\"125\" heading=\"Favoriet van Stan:\" description=\"De sfeer op een zwoele zomeravond in Washington Square Park, in het hart van het dorpse Greenwich Village, was aangenaam toen plotseling het weer omsloeg. Het was vluchten geblazen en ik stond met een man of 40, 50 te schuilen voor de regen onder de triomfboog.\" thb_heading_color=\"#b34a4c\" thb_text_color=\"#282828\" heading_font_size=\"17px\" description_font_size=\"16px\"][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_row_inner][vc_column_inner width=\"1/2\"][vc_raw_html]%3Cblockquote%20class%3D%22instagram-media%22%20data-instgrm-permalink%3D%22https%3A%2F%2Fwww.instagram.com%2Freel%2FC9ro0Zrt9N3%2F%3Futm_source%3Dig_embed%26amp%3Butm_campaign%3Dloading%22%20data-instgrm-version%3D%2214%22%20style%3D%22%20background%3A%23FFF%3B%20border%3A0%3B%20border-radius%3A3px%3B%20box-shadow%3A0%200%201px%200%20rgba%280%2C0%2C0%2C0.5%29%2C0%201px%2010px%200%20rgba%280%2C0%2C0%2C0.15%29%3B%20margin%3A%201px%3B%20max-width%3A540px%3B%20min-width%3A326px%3B%20padding%3A0%3B%20width%3A99.375%25%3B%20width%3A-webkit-calc%28100%25%20-%202px%29%3B%20width%3Acalc%28100%25%20-%202px%29%3B%22%3E%3Cdiv%20style%3D%22padding%3A16px%3B%22%3E%20%3Ca%20href%3D%22https%3A%2F%2Fwww.instagram.com%2Freel%2FC9ro0Zrt9N3%2F%3Futm_source%3Dig_embed%26amp%3Butm_campaign%3Dloading%22%20style%3D%22%20background%3A%23FFFFFF%3B%20line-height%3A0%3B%20padding%3A0%200%3B%20text-align%3Acenter%3B%20text-decoration%3Anone%3B%20width%3A100%25%3B%22%20target%3D%22_blank%22%3E%20%3Cdiv%20style%3D%22%20display%3A%20flex%3B%20flex-direction%3A%20row%3B%20align-items%3A%20center%3B%22%3E%20%3Cdiv%20style%3D%22background-color%3A%20%23F4F4F4%3B%20border-radius%3A%2050%25%3B%20flex-grow%3A%200%3B%20height%3A%2040px%3B%20margin-right%3A%2014px%3B%20width%3A%2040px%3B%22%3E%3C%2Fdiv%3E%20%3Cdiv%20style%3D%22display%3A%20flex%3B%20flex-direction%3A%20column%3B%20flex-grow%3A%201%3B%20justify-content%3A%20center%3B%22%3E%20%3Cdiv%20style%3D%22%20background-color%3A%20%23F4F4F4%3B%20border-radius%3A%204px%3B%20flex-grow%3A%200%3B%20height%3A%2014px%3B%20margin-bottom%3A%206px%3B%20width%3A%20100px%3B%22%3E%3C%2Fdiv%3E%20%3Cdiv%20style%3D%22%20background-color%3A%20%23F4F4F4%3B%20border-radius%3A%204px%3B%20flex-grow%3A%200%3B%20height%3A%2014px%3B%20width%3A%2060px%3B%22%3E%3C%2Fdiv%3E%3C%2Fdiv%3E%3C%2Fdiv%3E%3Cdiv%20style%3D%22padding%3A%2019%25%200%3B%22%3E%3C%2Fdiv%3E%20%3Cdiv%20style%3D%22display%3Ablock%3B%20height%3A50px%3B%20margin%3A0%20auto%2012px%3B%20width%3A50px%3B%22%3E%3Csvg%20width%3D%2250px%22%20height%3D%2250px%22%20viewBox%3D%220%200%2060%2060%22%20version%3D%221.1%22%20xmlns%3D%22https%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22https%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%3E%3Cg%20stroke%3D%22none%22%20stroke-width%3D%221%22%20fill%3D%22none%22%20fill-rule%3D%22evenodd%22%3E%3Cg%20transform%3D%22translate%28-511.000000%2C%20-20.000000%29%22%20fill%3D%22%23000000%22%3E%3Cg%3E%3Cpath%20d%3D%22M556.869%2C30.41%20C554.814%2C30.41%20553.148%2C32.076%20553.148%2C34.131%20C553.148%2C36.186%20554.814%2C37.852%20556.869%2C37.852%20C558.924%2C37.852%20560.59%2C36.186%20560.59%2C34.131%20C560.59%2C32.076%20558.924%2C30.41%20556.869%2C30.41%20M541%2C60.657%20C535.114%2C60.657%20530.342%2C55.887%20530.342%2C50%20C530.342%2C44.114%20535.114%2C39.342%20541%2C39.342%20C546.887%2C39.342%20551.658%2C44.114%20551.658%2C50%20C551.658%2C55.887%20546.887%2C60.657%20541%2C60.657%20M541%2C33.886%20C532.1%2C33.886%20524.886%2C41.1%20524.886%2C50%20C524.886%2C58.899%20532.1%2C66.113%20541%2C66.113%20C549.9%2C66.113%20557.115%2C58.899%20557.115%2C50%20C557.115%2C41.1%20549.9%2C33.886%20541%2C33.886%20M565.378%2C62.101%20C565.244%2C65.022%20564.756%2C66.606%20564.346%2C67.663%20C563.803%2C69.06%20563.154%2C70.057%20562.106%2C71.106%20C561.058%2C72.155%20560.06%2C72.803%20558.662%2C73.347%20C557.607%2C73.757%20556.021%2C74.244%20553.102%2C74.378%20C549.944%2C74.521%20548.997%2C74.552%20541%2C74.552%20C533.003%2C74.552%20532.056%2C74.521%20528.898%2C74.378%20C525.979%2C74.244%20524.393%2C73.757%20523.338%2C73.347%20C521.94%2C72.803%20520.942%2C72.155%20519.894%2C71.106%20C518.846%2C70.057%20518.197%2C69.06%20517.654%2C67.663%20C517.244%2C66.606%20516.755%2C65.022%20516.623%2C62.101%20C516.479%2C58.943%20516.448%2C57.996%20516.448%2C50%20C516.448%2C42.003%20516.479%2C41.056%20516.623%2C37.899%20C516.755%2C34.978%20517.244%2C33.391%20517.654%2C32.338%20C518.197%2C30.938%20518.846%2C29.942%20519.894%2C28.894%20C520.942%2C27.846%20521.94%2C27.196%20523.338%2C26.654%20C524.393%2C26.244%20525.979%2C25.756%20528.898%2C25.623%20C532.057%2C25.479%20533.004%2C25.448%20541%2C25.448%20C548.997%2C25.448%20549.943%2C25.479%20553.102%2C25.623%20C556.021%2C25.756%20557.607%2C26.244%20558.662%2C26.654%20C560.06%2C27.196%20561.058%2C27.846%20562.106%2C28.894%20C563.154%2C29.942%20563.803%2C30.938%20564.346%2C32.338%20C564.756%2C33.391%20565.244%2C34.978%20565.378%2C37.899%20C565.522%2C41.056%20565.552%2C42.003%20565.552%2C50%20C565.552%2C57.996%20565.522%2C58.943%20565.378%2C62.101%20M570.82%2C37.631%20C570.674%2C34.438%20570.167%2C32.258%20569.425%2C30.349%20C568.659%2C28.377%20567.633%2C26.702%20565.965%2C25.035%20C564.297%2C23.368%20562.623%2C22.342%20560.652%2C21.575%20C558.743%2C20.834%20556.562%2C20.326%20553.369%2C20.18%20C550.169%2C20.033%20549.148%2C20%20541%2C20%20C532.853%2C20%20531.831%2C20.033%20528.631%2C20.18%20C525.438%2C20.326%20523.257%2C20.834%20521.349%2C21.575%20C519.376%2C22.342%20517.703%2C23.368%20516.035%2C25.035%20C514.368%2C26.702%20513.342%2C28.377%20512.574%2C30.349%20C511.834%2C32.258%20511.326%2C34.438%20511.181%2C37.631%20C511.035%2C40.831%20511%2C41.851%20511%2C50%20C511%2C58.147%20511.035%2C59.17%20511.181%2C62.369%20C511.326%2C65.562%20511.834%2C67.743%20512.574%2C69.651%20C513.342%2C71.625%20514.368%2C73.296%20516.035%2C74.965%20C517.703%2C76.634%20519.376%2C77.658%20521.349%2C78.425%20C523.257%2C79.167%20525.438%2C79.673%20528.631%2C79.82%20C531.831%2C79.965%20532.853%2C80.001%20541%2C80.001%20C549.148%2C80.001%20550.169%2C79.965%20553.369%2C79.82%20C556.562%2C79.673%20558.743%2C79.167%20560.652%2C78.425%20C562.623%2C77.658%20564.297%2C76.634%20565.965%2C74.965%20C567.633%2C73.296%20568.659%2C71.625%20569.425%2C69.651%20C570.167%2C67.743%20570.674%2C65.562%20570.82%2C62.369%20C570.966%2C59.17%20571%2C58.147%20571%2C50%20C571%2C41.851%20570.966%2C40.831%20570.82%2C37.631%22%3E%3C%2Fpath%3E%3C%2Fg%3E%3C%2Fg%3E%3C%2Fg%3E%3C%2Fsvg%3E%3C%2Fdiv%3E%3Cdiv%20style%3D%22padding-top%3A%208px%3B%22%3E%20%3Cdiv%20style%3D%22%20color%3A%233897f0%3B%20font-family%3AArial%2Csans-serif%3B%20font-size%3A14px%3B%20font-style%3Anormal%3B%20font-weight%3A550%3B%20line-height%3A18px%3B%22%3EDit%20bericht%20op%20Instagram%20bekijken%3C%2Fdiv%3E%3C%2Fdiv%3E%3Cdiv%20style%3D%22padding%3A%2012.5%25%200%3B%22%3E%3C%2Fdiv%3E%20%3Cdiv%20style%3D%22display%3A%20flex%3B%20flex-direction%3A%20row%3B%20margin-bottom%3A%2014px%3B%20align-items%3A%20center%3B%22%3E%3Cdiv%3E%20%3Cdiv%20style%3D%22background-color%3A%20%23F4F4F4%3B%20border-radius%3A%2050%25%3B%20height%3A%2012.5px%3B%20width%3A%2012.5px%3B%20transform%3A%20translateX%280px%29%20translateY%287px%29%3B%22%3E%3C%2Fdiv%3E%20%3Cdiv%20style%3D%22background-color%3A%20%23F4F4F4%3B%20height%3A%2012.5px%3B%20transform%3A%20rotate%28-45deg%29%20translateX%283px%29%20translateY%281px%29%3B%20width%3A%2012.5px%3B%20flex-grow%3A%200%3B%20margin-right%3A%2014px%3B%20margin-left%3A%202px%3B%22%3E%3C%2Fdiv%3E%20%3Cdiv%20style%3D%22background-color%3A%20%23F4F4F4%3B%20border-radius%3A%2050%25%3B%20height%3A%2012.5px%3B%20width%3A%2012.5px%3B%20transform%3A%20translateX%289px%29%20translateY%28-18px%29%3B%22%3E%3C%2Fdiv%3E%3C%2Fdiv%3E%3Cdiv%20style%3D%22margin-left%3A%208px%3B%22%3E%20%3Cdiv%20style%3D%22%20background-color%3A%20%23F4F4F4%3B%20border-radius%3A%2050%25%3B%20flex-grow%3A%200%3B%20height%3A%2020px%3B%20width%3A%2020px%3B%22%3E%3C%2Fdiv%3E%20%3Cdiv%20style%3D%22%20width%3A%200%3B%20height%3A%200%3B%20border-top%3A%202px%20solid%20transparent%3B%20border-left%3A%206px%20solid%20%23f4f4f4%3B%20border-bottom%3A%202px%20solid%20transparent%3B%20transform%3A%20translateX%2816px%29%20translateY%28-4px%29%20rotate%2830deg%29%22%3E%3C%2Fdiv%3E%3C%2Fdiv%3E%3Cdiv%20style%3D%22margin-left%3A%20auto%3B%22%3E%20%3Cdiv%20style%3D%22%20width%3A%200px%3B%20border-top%3A%208px%20solid%20%23F4F4F4%3B%20border-right%3A%208px%20solid%20transparent%3B%20transform%3A%20translateY%2816px%29%3B%22%3E%3C%2Fdiv%3E%20%3Cdiv%20style%3D%22%20background-color%3A%20%23F4F4F4%3B%20flex-grow%3A%200%3B%20height%3A%2012px%3B%20width%3A%2016px%3B%20transform%3A%20translateY%28-4px%29%3B%22%3E%3C%2Fdiv%3E%20%3Cdiv%20style%3D%22%20width%3A%200%3B%20height%3A%200%3B%20border-top%3A%208px%20solid%20%23F4F4F4%3B%20border-left%3A%208px%20solid%20transparent%3B%20transform%3A%20translateY%28-4px%29%20translateX%288px%29%3B%22%3E%3C%2Fdiv%3E%3C%2Fdiv%3E%3C%2Fdiv%3E%20%3Cdiv%20style%3D%22display%3A%20flex%3B%20flex-direction%3A%20column%3B%20flex-grow%3A%201%3B%20justify-content%3A%20center%3B%20margin-bottom%3A%2024px%3B%22%3E%20%3Cdiv%20style%3D%22%20background-color%3A%20%23F4F4F4%3B%20border-radius%3A%204px%3B%20flex-grow%3A%200%3B%20height%3A%2014px%3B%20margin-bottom%3A%206px%3B%20width%3A%20224px%3B%22%3E%3C%2Fdiv%3E%20%3Cdiv%20style%3D%22%20background-color%3A%20%23F4F4F4%3B%20border-radius%3A%204px%3B%20flex-grow%3A%200%3B%20height%3A%2014px%3B%20width%3A%20144px%3B%22%3E%3C%2Fdiv%3E%3C%2Fdiv%3E%3C%2Fa%3E%3Cp%20style%3D%22%20color%3A%23c9c8cd%3B%20font-family%3AArial%2Csans-serif%3B%20font-size%3A14px%3B%20line-height%3A17px%3B%20margin-bottom%3A0%3B%20margin-top%3A8px%3B%20overflow%3Ahidden%3B%20padding%3A8px%200%207px%3B%20text-align%3Acenter%3B%20text-overflow%3Aellipsis%3B%20white-space%3Anowrap%3B%22%3E%3Ca%20href%3D%22https%3A%2F%2Fwww.instagram.com%2Freel%2FC9ro0Zrt9N3%2F%3Futm_source%3Dig_embed%26amp%3Butm_campaign%3Dloading%22%20style%3D%22%20color%3A%23c9c8cd%3B%20font-family%3AArial%2Csans-serif%3B%20font-size%3A14px%3B%20font-style%3Anormal%3B%20font-weight%3Anormal%3B%20line-height%3A17px%3B%20text-decoration%3Anone%3B%22%20target%3D%22_blank%22%3EEen%20bericht%20gedeeld%20door%20%F0%9F%97%BD%20NWYRK%20%28%40nwyrk%29%3C%2Fa%3E%3C%2Fp%3E%3C%2Fdiv%3E%3C%2Fblockquote%3E%20%3Cscript%20async%20src%3D%22%2F%2Fwww.instagram.com%2Fembed.js%22%3E%3C%2Fscript%3E[/vc_raw_html][/vc_column_inner][vc_column_inner width=\"1/2\"][vc_column_text]<strong>Tijd voor treurnis was er niet. De muzikant met zijn verrijdbare gettoblaster bleek een geweldig gevoel voor timing en over een voortreffelijke muzieksmaak te beschikken. Hij reed zijn karretje snel richting de arch en zette muziek op.</strong>\r\n\r\n<strong>It\u2019s raining man, halleluja</strong>\r\nHet lijflied van de LGBTQIA+-gemeenschap kon rekenen op een warm onthaal en ontaardde al snel in vrolijke sing-along. God bless mother nature, klonk het uit de vele kelen. De muzikant pakte zijn Spotify-lijst er nog maar eens even bij. Natasha Bedingfield kwam uit de hoge hoed.<em> \u2018Feel the rain on your skin, no one else can feel it for you, only you can let it in\u2019</em>. De passie waarmee het nummer werd gezongen, zie je hooguit bij een concert, maar dus \u00f3\u00f3k op deze avond in Washington Square Park.\r\n\r\nHet ene blowtje na het andere werd aangestoken, zelfs als niet-roker stond je haast onder curatele van het gem\u00ealeerde gezelschap met diverse achtergronden, leeftijd of seksuele ori\u00ebntatie. Rihanna kwam voorbij met Umbrella, wat het gevoel voor muzieksmaak tijdens de regenbui nog eens onderstreepte. Vooral bij het deel met<em> \u2018ella, ella, ella\u2019</em>, vlak na de zin<em> \u2018Under my umbrella\u2019</em>, kon rekenen op veel vocale bijval van de schuilers.\r\n\r\n<strong>I kissed a girl</strong>\r\nDe jonge vrouwen die speciaal voor het Pride-weekend naar New York waren afgereisd, werden op hun wenken bediend. De stem van Katy Perry schalde uit de box:<em> I kissed a girl and I liked it</em>! Het progressieve New York leek in Washington Square Park uit zijn voegen te barsten.\r\n\r\nDe regen kletterde onvermoeibaar door, de eensgezindheid onder de arch was een <em>\u2018once in a lifetime experience\u2019</em>. In ingewikkelde tijden voor Amerika vormde een groepje van 40, 50 mensen de passie en veerkracht waar het zo land zo om bekendstaat. Zelfs, of misschien wel vooral, dankzij <em>\u2018the rain on your skin\u2019</em>![/vc_column_text][/vc_column_inner][/vc_row_inner][/vc_column][/vc_row][vc_row thb_full_width=\"true\" css=\".vc_custom_1721555005330{background-color: #000000 !important;}\"][vc_column][fullwidth_row content_width=\"100%\"][parallax_row opacity=\"90\" image=\"20251\"][vc_empty_space height=\"350px\"][heyusa_heading tag=\"div\" text_align=\"center\" heading=\"Universiteitsgebouw aan Washington Square Park\" font_size=\"65\" line_height=\"70\" font_color=\"#ffffff\"][vc_custom_heading text=\"NYU - New York University\" font_container=\"tag:h2|font_size:65|text_align:center|color:%23ffffff|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_empty_space height=\"350px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"100%\"][vc_empty_space height=\"50px\"][vc_row_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][vc_column_inner width=\"2/3\"][vc_custom_heading text=\"New York University\" font_container=\"tag:h2|font_size:45|text_align:center|color:%23b34a4c|line_height:1\" google_fonts=\"font_family:Alfa%20Slab%20One%3Aregular|font_style:400%20regular%3A400%3Anormal\"][vc_column_text]\r\n<p style=\"text-align: center;\">Rondom Washington Square Park bevinden zich verschillende universiteitsgebouwen \u00e9n campussen van <a href=\"https://www.nyu.edu\" target=\"_blank\" rel=\"noopener\">NYU</a>. De New York-universiteit is de grootste particuliere universiteit van de Verenigde Staten en werd in 1831 opgericht door Albert Gallatin. Er zijn meer dan 170 universiteitsgebouwen in New York City te vinden van NYU, waarvan het merendeel aan en rond Washington Square Park.</p>\r\n[/vc_column_text][/vc_column_inner][vc_column_inner width=\"1/6\"][/vc_column_inner][/vc_row_inner][vc_empty_space height=\"50px\"][/vc_column][/vc_row][vc_row][vc_column][fullwidth_row content_width=\"95%\"][thb_postbackground style=\"style2\" source=\"post_type:post|by_id:1011,12568,661,545\"][/vc_column][/vc_row]","post_title":"Washington Square Park","post_link":"https://www.heyusa.com/nl/washington-square-park-new-york-city/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Washington Square Park\" width=\"300\" height=\"200\" src=\"https://www.heyusa.com/nl/wp-content/uploads/2020/03/Washington-square-park-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Parken New York","post_tags":"","%_edit_last%":"1","%_edit_lock%":"1721638856:1","%_thumbnail_id%":"144","%_wpb_vc_js_status%":"true","%post-primary-category%":"auto","%featured_image_override%":"off","%article_style_override%":"on","%post_style%":"style5","%post_gallery_style%":"lightbox","%post_review%":"off","%post_review_style%":"style1","%post_review_average%":"50","%thb_all_counts%":"0","%_hide_featured%":null,"%_yoast_wpseo_focuskw%":"Washington Square Park in New York","%_yoast_wpseo_title%":"Washington Square Park in New York%%page%% %%sep%% %%sitename%%","%_yoast_wpseo_metadesc%":"Washington Square Park in New York met de bekende 'arch' triomfboog is \u00e9\u00e9n van de iconische parken van de stad en het thuis van de NYU campus.","%_yoast_wpseo_linkdex%":"77","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_focuskeywords%":"[]","%_yoast_wpseo_keywordsynonyms%":"[\"\"]","%inline_featured_image%":"0","%_wpgmp_location_address%":"Washington Square, New York, NY 10012, Verenigde Staten","%_wpgmp_location_city%":"New York","%_wpgmp_location_state%":"New York","%_wpgmp_location_country%":"Verenigde Staten","%_wpgmp_metabox_latitude%":"40.7308838","%_wpgmp_metabox_longitude%":"-73.997332","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"7","%_yoast_indexnow_last_ping%":"1721561275","%activeer_submenu%":"1","%_activeer_submenu%":"field_6593f521e97c2","%locatie_submenu%":"Selecteer een pagina","%_locatie_submenu%":"field_6593f531e97c3","%selecteer_pagina%":"18453","%_selecteer_pagina%":"field_6593f8be019da","%_wws_support_contact_number%":"","%_wws_about_support_text%":"","%_wws_trigger_button_text%":"","%_wws_predefined_text%":"","%_yoast_wpseo_primary_category%":"","%_wpb_shortcodes_custom_css%":".vc_custom_1721555005330{background-color: #000000 !important;}.vc_custom_1721555005330{background-color: #000000 !important;}.vc_custom_1721555005330{background-color: #000000 !important;}","taxonomy=category":"Parken New York","taxonomy=post_tag":"","taxonomy=post_format":"","taxonomy=thb-reactions":"","taxonomy=thb-sponsors":""},"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/park-icon.png"},"id":143,"infowindow_disable":false,"categories":[{"icon":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/park-icon.png","name":"Parken","id":"3","type":"category","extension_fields":{"cat_order":""}}]}],"map_property":{"map_id":"7","debug_mode":false},"shapes":{"drawing_editable":false},"filters":{"filters_container":"[data-container=\"wpgmp-filters-container\"]"},"marker_category_icons":{"1":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/buurt-1.png","2":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/musea-icon.png","3":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/park-icon.png","4":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/stad.png","5":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bezienswaardigheid.png","6":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/ghosttown.png","7":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/parken.png","9":"https://www.heyusa.com/nl/wp-content/uploads/2024/03/beach-icon.png","10":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/stad.png","11":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/stad.png","12":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/stad.png","13":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/hotel.png","14":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/trail-park.png","15":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/food.png","16":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/shop.png","17":"https://www.heyusa.com/nl/wp-content/uploads/2021/04/bars-cafes.png","18":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/standaard-locatie.png","19":"https://www.heyusa.com/nl/wp-content/uploads/2021/06/festivals.png","20":"https://www.heyusa.com/nl/wp-content/uploads/2021/09/icon-capital.png"}} Staten Island Ferry in New YorkVaar gratis langs het Vrijheidsbeeld De Staten Island Ferry…
Harlem
Harlem Hip-hop rondleiding

Boottocht van 90 minuten over de Hudson en East River

De wijk Harlem in New York City
Harlem Gospel & Brunch Tour

Boottocht van 90 minuten over de Hudson en East River

Prospect Park Boathouse in Brooklyn
Rondleiding Prospect Park
Rondleiding Prospect Park in BrooklynHet Central Park van BrooklynBESTEL TICKETS Een leuke manier om kennis…
Bow Bridge
Central Park tour langs filmlocaties
Filmlocaties in Central ParkBestel je tickets Wanneer je voor het eerst in New York bent…
Rondleiding Central Park
Rondleiding door Central Park
Rondleiding door Central ParkBestel je tickets Het groene hart van Manhattan is enorm groot en…
Foodtour door Chinatown & Little Italy
Foodtour door Chinatown & Little ItalyDe smaken en keukens van Chinatown en Little ItalyBESTEL TICKETS…
Lower East Side
Culinaire rondleiding door de Lower East Side
Ga mee tijdens een culinaire rondleiding door de Lower East SideOntdek de smaken van deze…
Little Italy
Rondleiding door SoHo, Chinatown en Little Italy
Ontdek SoHo, Chinatown en Little Italy tijdens deze 3 buurten rondleidingLeuke, betaalbare tour door deze…
Brooklyn rondleiding
Brooklyn Walking Tour
Wandel via de Brooklyn Bridge naar DUMBO, Brooklyn Heights en Brooklyn Bridge ParkOntdek Brooklyn met…