{"map_options":{"center_lat":"42.187963","center_lng":"12.723061","zoom":18,"map_type_id":"SATELLITE","center_by_nearest":false,"fit_bounds":false,"center_circle_fillcolor":"#8CAEF2","center_circle_fillopacity":"100%","center_circle_strokecolor":"#bc6d6d","show_center_circle":false,"show_center_marker":true,"center_marker_icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/geopin-4.png","center_marker_infowindow":"<p>Punto di partenza dell'itinerario<\/p>\n","draggable":true,"scroll_wheel":"true","gesture":"auto","infowindow_setting":"<div class=\"fc-item-box fc-item-no-padding\">\n    {post_featured_image}<\/p>\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\">{post_categories}<\/div>\n<div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">{post_title}<\/div>\n<div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\n                {post_excerpt}\n<\/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 style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"{post_link}\" class=\"fc-post-link\">{post_title}<\/a><\/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    {post_featured_image}\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\">{post_categories}<\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">{post_title}<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                {post_excerpt}\r\n<\/div>\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 style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"{post_link}\" class=\"fc-post-link\">{post_title}<\/a><\/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_bounce_animation":"mouseover","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":false,"locateme_control":false,"mobile_specific":false,"zoom_mobile":5,"draggable_mobile":true,"scroll_wheel_mobile":true,"full_screen_control_position":"TOP_RIGHT","search_control_position":"TOP_LEFT","locateme_control_position":"TOP_LEFT","zoom_control_position":"TOP_LEFT","map_type_control_position":"TOP_RIGHT","map_type_control_style":"HORIZONTAL_BAR","street_view_control_position":"TOP_LEFT","map_control":false,"screens":{"smartphones":{"map_zoom_level_mobile":"5"},"ipads":{"map_zoom_level_mobile":"5"},"large-screens":{"map_zoom_level_mobile":"5"}},"map_infowindow_customisations":false,"infowindow_width":"100%","infowindow_border_color":"rgba(0, 0, 0, 0.0980392)","infowindow_bg_color":"#000000","show_infowindow_header":false,"min_zoom":"0","max_zoom":"19","zoom_level_after_search":"10","url_filters":false,"doubleclickzoom":false,"current_post_only":false,"bound_map_after_filter":false,"display_reset_button":false,"map_reset_button_text":"Reset","height":"600"},"places":[{"source":"post","title":"The Routes of Oil","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 Routes of Oil\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari-naturalistici-anteprima-300x191.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/en\/routes\/the-routes-of-oil\/\" class=\"fc-post-link\">The Routes of Oil<\/a><\/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":"Piazza Luigi, Piazzale Pacieri, 3, 02032 Canneto RI, Italia","location":{"lat":"42.187963","city":"Fara in Sabina","state":"Lazio","country":"Italia","lng":"12.723061","redirect_custom_link":"","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/en\/routes\/the-routes-of-oil\/","zoom":18,"extra_fields":{"post_excerpt":"","post_content":"[vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row][vc_column][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Le Vie dell\u2019<strong>Olio <\/strong>e l'<strong>Abazia di Farfa<\/strong><\/h2>\r\n[\/vc_column_text][vc_column_text css=\".vc_custom_1696936649516{margin-top: -20px !important;}\"]\r\n<h5>Itinerario Naturalistico &amp; Artistico<\/h5>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column][\/vc_row][vc_row gap=\"20\" css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/4\" css=\".vc_custom_1696326100559{border-top-width: 10px !important;border-right-width: 10px !important;border-bottom-width: 10px !important;border-left-width: 10px !important;padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;background-color: #f4f4f4 !important;border-left-color: #ffffff !important;border-left-style: solid !important;border-right-color: #ffffff !important;border-right-style: solid !important;border-top-color: #ffffff !important;border-top-style: solid !important;border-bottom-color: #ffffff !important;border-bottom-style: solid !important;}\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-sm vc_hidden-xs\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_single_image image=\"9145\" img_size=\"full\" alignment=\"center\" onclick=\"custom_link\" el_class=\"itinerari\" link=\"https:\/\/geosabina.it\/itinerari\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner el_class=\"info_app\" css=\".vc_custom_1696325961236{padding: 20px !important;}\"][vc_column_inner][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\"><strong>Tipologia<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696326193021{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Percorso in Auto e a Piedi<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\"><strong>Numero Tappe<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696326261455{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">3<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\"><strong>Durata<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696326280823{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">1 Giorno<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\"><strong>Difficolt\u00e0<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696326295906{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Facile<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\"><strong>Punto di Partenza<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696349541619{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Magliano Sabina<\/span><\/strong>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"3\/4\"][vc_column_text]<strong>Sabina is the land of the olive<\/strong> par excellence, just 50 kilometers from Rome, it offers wonderful opportunities for recreation, between the natural beauty, architecture of ancient villages, fine food and a 'unique welcome, it amazes in all seasons. Oil is the pretext for discovering this enchanting land.[\/vc_column_text][vc_empty_space height=\"30px\"][vc_tta_tour shape=\"square\" color=\"green\" spacing=\"20\" gap=\"15\" active_section=\"1\" no_fill_content_area=\"true\" title=\"Itinerario\"][vc_tta_section title=\"TAPPA 1\" tab_id=\"1696344647582-eada1aca-2c359ab0-c178\"][vc_column_text]\r\n<h4>Canneto Olive Tree<\/h4>\r\nFirst stop, which is both necessary and a must, is a visit to the <strong>Ulivone di Canneto<\/strong>. A very old (apparently approaching 2,000 years old) tree located on the private estate of the Bertini brothers. The tree measures 7 meters in circumference and legend has it that it was the king of Rome Numa Pompilius who drilled it, and it has an annual production of about 12 quintals of olives.\r\n\r\nOlive trees have always represented the Sabine territory with their varieties, the most common being frantoio, leccino, carboncella and rosciola.[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Indicazioni stradali punto di partenza tappa 1\" style=\"outline\" shape=\"square\" color=\"green\" i_align=\"right\" i_icon_fontawesome=\"fas fa-route\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2F02046%2BMagliano%2BSabina%2BRI%2F%4042.3659807%2C12.4645762%2C15z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132f19ad59225c53%3A0xda3972f1f8315b57!8m2!3d42.364143!4d12.4788065!16zL20vMGdtNWwx%3Fentry%3Dttu|target:_blank\"][\/vc_column_inner][vc_column_inner width=\"1\/2\" offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_btn title=\"Vai alla scheda del comune di Magliano\" style=\"outline\" shape=\"square\" color=\"warning\" i_align=\"right\" i_icon_fontawesome=\"far fa-file-alt\" add_icon=\"true\" link=\"url:https%3A%2F%2Fgeosabina.it%2Fdestinations%2Fmagliano-sabina%2F\"][\/vc_column_inner][\/vc_row_inner][\/vc_tta_section][vc_tta_section title=\"TAPPA 2\" tab_id=\"1696344647611-95d2120a-89629ab0-c178\"][vc_column_text]\r\n<h4><strong>Toffia<\/strong><\/h4>\r\nContinuing to Toffia, you can visit the village, a pretty characteristic village overlooking the valleys rich in natural beauty. Inside the village, jewels of the past present themselves to visitors such as Palazzo Castellani, Palazzo Gabrielli, not to mention every characteristic corner that makes for an enchanting stop.[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Indicazioni stradali punto di partenza tappa 2\" style=\"outline\" shape=\"square\" color=\"green\" i_align=\"right\" i_icon_fontawesome=\"fas fa-route\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2F02040%2BTarano%2BRI%2F%4042.3561363%2C12.5929325%2C17z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132f1ae6e399e251%3A0x73fd48edd89a9a20!8m2!3d42.3577773!4d12.5968303!16zL20vMGdtNmc3%3Fentry%3Dttu|target:_blank\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Vai alla scheda del comune di Toffia\" style=\"outline\" shape=\"square\" color=\"warning\" i_align=\"right\" i_icon_fontawesome=\"far fa-file-alt\" add_icon=\"true\" link=\"url:https%3A%2F%2Fgeosabina.it%2Fdestinations%2Ftoffia%2F\"][\/vc_column_inner][\/vc_row_inner][\/vc_tta_section][vc_tta_section title=\"TAPPA 3\" tab_id=\"1696344891500-aa2c7edd-9eb69ab0-c178\"][vc_column_text]\r\n<div class=\"wpb_text_column wpb_content_element \">\r\n<div class=\"wpb_wrapper\">\r\n<h4><strong>Abbey of Farfa<\/strong><\/h4>\r\n<div class=\"wpb_text_column wpb_content_element \">\r\n<div class=\"wpb_wrapper\">\r\n\r\nThe third leg of the oil vide includes L' Abazia di Farfa\r\n\r\nFarfa Abbey, located in the municipality of Fara in Sabina, province of Rieti, Lazio, is one of the oldest and most important abbeys in Italy, with a history dating back to the 8th century. Founded in 680 AD by Benedictine monks led by St. Thomas of Moor, the abbey played a crucial role in preserving knowledge and traditions during the medieval European period, becoming a religious and cultural center of great significance.\r\n\r\nThe abbey is also known for its library, which preserves medieval manuscripts and texts of inestimable historical and artistic value. Today, Farfa Abbey continues to be an active place of worship, welcoming worshippers and visitors interested in exploring its fascinating history and admiring its beautiful architecture.\r\n\r\n<\/div>\r\n<\/div>\r\n<div class=\"vc_row wpb_row vc_inner vc_row-fluid video_app\"><\/div>\r\n<\/div>\r\n<\/div>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Indicazioni stradali punto di partenza tappa 3\" style=\"outline\" shape=\"square\" color=\"green\" i_align=\"right\" i_icon_fontawesome=\"fas fa-route\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.com%2Fmaps%2Fplace%2FAbbazia%2BBenedettina%2Bdi%2BSanta%2BMaria%2Bdi%2BFarfa%2F%4042.2208353%2C12.7184335%2C19.17z%2Fdata%3D!4m21!1m14!4m13!1m6!1m2!1s0x132f0bf730d18831%3A0x96074f530401e799!2sAbbazia%2BBenedettina%2Bdi%2BSanta%2BMaria%2Bdi%2BFarfa%2C%2BVia%2Bdi%2BPorta%2BMontopoli%2C%2BFara%2Bin%2BSabina%2C%2BRI!2m2!1d12.7187673!2d42.2208883!1m5!1m1!2s46.045089%2C11.129826!2m2!1d11.129826!2d46.045089!3m5!1s0x132f0bf730d18831%3A0x96074f530401e799!8m2!3d42.220882!4d12.7187574!16zL20vMDkwMXNy%3Fhl%3Dit%26entry%3Dttu|target:_blank\"][\/vc_column_inner][vc_column_inner width=\"1\/2\" offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_btn title=\"Vai alla scheda del Santuario di Vescovio\" style=\"outline\" shape=\"square\" color=\"warning\" i_align=\"right\" i_icon_fontawesome=\"far fa-file-alt\" add_icon=\"true\" link=\"url:https%3A%2F%2Fgeosabina.it%2Faltri-comuni%2Fvescovio-area-archeologica-forum-novum-e-santuario%2F\"][\/vc_column_inner][\/vc_row_inner][\/vc_tta_section][vc_tta_section title=\"TAPPA 4\" tab_id=\"1696936747830-d25e7c2a-89f5\"][vc_column_text]\r\n<h4><strong>Sabina Oil Museum<\/strong><\/h4>\r\nFor our fourth stop is the Museo dell'Olio della Sabina, a facility located in Castelnuovo di Farfa, in the province of Rieti, entirely dedicated to the history and culture of olive growing in the Sabina region, in the heart of central Italy.\r\n\r\nFounded in 2009 by the Cultural Association \"L'Olio della Sabina,\" the main purpose of the museum is to promote and spread knowledge of Sabine extra virgin olive oil, an internationally recognized high quality product.\r\n\r\nThe museum is housed in Palazzo Perelli, a charming 16th-century building located in the town's historic center. The museum's exhibition itinerary is divided into four well-defined thematic sections:\r\n<ol>\r\n \t<li><strong>The History of Oil in Sabina:<\/strong> This section offers a journey through the history of olive growing in the region, starting from prehistory to the present day.<\/li>\r\n \t<li><strong>The Cultivation of the Olive Tree:<\/strong> Here the various techniques used in olive cultivation are explained, from the beginning of the cycle with planting to the olive harvesting stage.<\/li>\r\n \t<li><strong>Oil Production:<\/strong> This section delves into the different stages involved in olive oil production, from the importance of pressing to the intricate procedure of preservation.<\/li>\r\n \t<li><strong>Oil in the kitchen:<\/strong> This part of the museum explores the use of oil in traditional Sabina cuisine, emphasizing its importance in local gastronomy.<\/li>\r\n<\/ol>\r\nIn addition to its permanent exhibition, the museum organizes a series of educational activities and workshops designed for both adults and children, offering an interactive and educational experience for all visitors interested in discovering the fascinating and ancient world of olive oil in Sabina.\r\n\r\nFOR INFO AND HOURS GO DIRECTLY TO THE MUSEUM WEBSITE FROM THE BUTTON BELOW[\/vc_column_text][vc_empty_space height=\"20px\"][vc_row_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Indicazioni stradali punto di partenza tappa 4\" style=\"outline\" shape=\"square\" color=\"success\" i_icon_fontawesome=\"fas fa-map-signs\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.com%2Fmaps%2Fplace%2FMuseo%2Bdell'Olio%2Bdella%2BSabina%2F%4042.2316027%2C12.7432582%2C18.54z%2Fdata%3D!4m19!1m12!4m11!1m6!1m2!1s0x132f09622e0a58b5%3A0x9720c280832c9415!2sMuseo%2Bdell'Olio%2Bdella%2BSabina%2C%2BViale%2BRegina%2BMargherita%2C%2BCastelnuovo%2Bdi%2BFarfa%2C%2BRI!2m2!1d12.7430334!2d42.2320084!1m3!2m2!1d12.743891!2d42.2323823!3m5!1s0x132f09622e0a58b5%3A0x9720c280832c9415!8m2!3d42.2320084!4d12.7430334!16s%252Fg%252F12hm23k1p%3Fhl%3Dit%26entry%3Dttu\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"OLIVE OIL MUSEUM PAGE\" style=\"outline\" shape=\"square\" color=\"warning\" i_icon_fontawesome=\"fas fa-map-signs\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.castelnuovodifarfaturismo.it%2Fscopri-museo-dell-olio\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][\/vc_row_inner][\/vc_tta_section][vc_tta_section title=\"TAPPA 5\" tab_id=\"1696936785330-ce488292-326a\"][vc_column_text]\r\n<h4><strong>\u00a0Montopoli di Sabina<\/strong><\/h4>\r\nThe Tour continues to <strong>Montopoli di Sabina<\/strong>, Two beautiful overlooks allow one to admire the valleys below: on one side the Tiber Valley and on the other side the plain stretching all the way to Rome. In the harvest season, which takes place in the fall, you can visit the surrounding olive mills, tasting the oil fresh from the separator[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Indicazioni stradali punto di partenza tappa 5\" style=\"outline\" shape=\"square\" color=\"success\" i_icon_fontawesome=\"fas fa-map-signs\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.com%2Fmaps%2Fplace%2F02034%2BMontopoli%2Bdi%2BSabina%2BRI%2F%4042.2272776%2C12.5101548%2C12z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132f0dcd3c2fd9af%3A0x4094f9ab239b530!8m2!3d42.2243368!4d12.6618145!16zL20vMGdtNXNq%3Fhl%3Dit%26entry%3Dttu\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Vai alla scheda di Montopoli di Sabina\" style=\"outline\" shape=\"square\" color=\"warning\" i_icon_fontawesome=\"fas fa-map-signs\" add_icon=\"true\" link=\"url:https%3A%2F%2Fgeosabina.it%2Fen%2Fdestinations%2Fmontopoli-di-sabina%2F\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][\/vc_row_inner][\/vc_tta_section][\/vc_tta_tour][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][\/vc_column][\/vc_row]","post_title":"The Routes of Oil","post_link":"https:\/\/geosabina.it\/en\/routes\/the-routes-of-oil\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Routes of Oil\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari-naturalistici-anteprima-300x191.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_thumbnail_id%":"9196","%_edit_lock%":"1697446917:6","%_wpb_shortcodes_custom_css%":".vc_custom_1696936649516{margin-top: -20px !important;}.vc_custom_1696326100559{border-top-width: 10px !important;border-right-width: 10px !important;border-bottom-width: 10px !important;border-left-width: 10px !important;padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;background-color: #f4f4f4 !important;border-left-color: #ffffff !important;border-left-style: solid !important;border-right-color: #ffffff !important;border-right-style: solid !important;border-top-color: #ffffff !important;border-top-style: solid !important;border-bottom-color: #ffffff !important;border-bottom-style: solid !important;}.vc_custom_1696325961236{padding: 20px !important;}.vc_custom_1696326193021{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696326261455{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696326280823{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696326295906{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696349541619{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":340,\"to_translate\":{\"en\":340}}","%_wpml_location_migration_done%":"1","%_wpgmp_location_address%":"Piazza Luigi, Piazzale Pacieri, 3, 02032 Canneto RI, Italia","%_wpgmp_location_city%":"Fara in Sabina","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.187963","%_wpgmp_metabox_longitude%":"12.723061","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"3\";i:1;s:2:\"16\";i:2;s:2:\"17\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"19\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_wpb_post_custom_css%":".itinerari {\r\n    width:100%;\r\n    max-width:300px;\r\n}","%_dp_original%":"6846","%_edit_last%":"6","%_last_translation_edit_mode%":"native-editor","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"The Routes of Oil","%_yoast_wpseo_linkdex%":"56","taxonomy=translation_priority":"Optional, Optional"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari_sito.png"},"id":6964,"custom_filters":[],"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari_sito.png","name":"Itinerari Naturalistici \/ Nature Trails","id":"19","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Stimigliano \u2013 Forano e Oasi Tevere Farfa","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Stimigliano \u2013 Forano e Oasi Tevere Farfa\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/07\/itinerari-logo-300x191.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/en\/routes\/stimigliano-forano-e-oasi-tevere-farfa\/\" class=\"fc-post-link\">Stimigliano \u2013 Forano e Oasi Tevere Farfa<\/a><\/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":"02048 Stimigliano RI, Italia","location":{"lat":"42.3009899","city":"Stimigliano","state":"Lazio","country":"Italia","lng":"12.5628575","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/en\/routes\/stimigliano-forano-e-oasi-tevere-farfa\/","zoom":18,"extra_fields":{"post_excerpt":"","post_content":"<p>[vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/4\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-sm vc_hidden-xs\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_single_image image=\"9190\" img_size=\"full\" alignment=\"center\" onclick=\"custom_link\" el_class=\"itinerari\" link=\"https:\/\/geosabina.it\/itinerari\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner el_class=\"info_app\" css=\".vc_custom_1696325961236{padding: 20px !important;}\"][vc_column_inner][vc_column_text el_class=\"info-point\"]<\/p>\r\n<h4 style=\"padding-top: 5px;\"><strong>Tipologia<\/strong><\/h4>\r\n<p>[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696326193021{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Percorso in Auto e a Piedi<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]<\/p>\r\n<h4 style=\"padding-top: 5px;\"><strong>Numero Tappe<\/strong><\/h4>\r\n<p>[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696326261455{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">3<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]<\/p>\r\n<h4 style=\"padding-top: 5px;\"><strong>Durata<\/strong><\/h4>\r\n<p>[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696326280823{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">1 Giorno<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]<\/p>\r\n<h4 style=\"padding-top: 5px;\"><strong>Difficolt\u00e0<\/strong><\/h4>\r\n<p>[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696326295906{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Facile<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]<\/p>\r\n<h4 style=\"padding-top: 5px;\"><strong>Punto di Partenza<\/strong><\/h4>\r\n<p>[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696929178272{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Stimigliano<\/span><\/strong>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"3\/4\"][vc_empty_space height=\"40px\"][vc_column_text]<\/p>\r\n<h2>Stimigliano \u2013 Forano e <strong>Oasi Tevere Farfa<\/strong><\/h2>\r\n<p>[\/vc_column_text][vc_column_text]<\/p>\r\n<h5>Nature Itinerary<\/h5>\r\n<p>[\/vc_column_text][vc_empty_space height=\"40px\"][vc_column_text]In Sabine Region the beauty freely ranges from the natural one to the and artistic one. We would propose in this route three beautiful countries along the Tiber valley. From there, the Tevere Farfa Oasis is easily reachable.<\/p>\r\n<p>Leave Rome on the A1 to Orte, exit Ponzano-Soratte \u2013 direction SR657 towards Stimigliano.<\/p>\r\n<p>7 km driving , and in just 10 minutes you will reach the country.<\/p>\r\n<p>The town of Stimigliano is called \u201cthe Gate of Sabina\u201d. It is the first village youface up before Rome, leaving the highway. It gathered around the imposing Baronial Palace of the Orsini family, built and expanded work at various stages during the sixteenth century.<\/p>\r\n<p>In the palace, paintings of Taddeo Zuccari Federcio followers and images depicting the life of Joseph and Mary can be admired today. The beautiful medieval village is enhanced by the SS. Cosma e Damiano and the church of San Valentino.<\/p>\r\n<p>From the village you can admire a large part of the Bassa Sabina and the gentle curves of the Tiber.<\/p>\r\n<p>Leaving Stimigliano, you move to Forano by returning on the SR657 road, and leaving the highway on the right at the first roundabout. Go up to the land. Forano is a small town with a very ancient history. There you will find evidence of the Sabine appropriations as early as the ninth century b.C. During the Roman Empire, the countryside is depopulated and over the centuries it absorbs the identities of the local lords, until it became a free city in 1262.<\/p>\r\n<p>The impressive Palazzo Ducale, built around the thirteenth century, overlooking the ruins of an ancient fortress. Numerous churches: the S.S. Trinity and Assumption, built in the late seventeenth century, the nineteenth-century Waldensian Church and the Church of St. Sebastian among the others. The Memorial Park is marvellous, and it is dedicated to the fallen in of the First World War, from 1925.<\/p>\r\n<p>As for the Archeological side, Gavignano is small but important, with its traces of Roman walls. Aldobrandini Castle is one of the most interesting stops.<\/p>\r\n<p>Our journey is ending in a fascinating embrace of nature, the Tevere-Farfa Oasis.<\/p>\r\n<p>It can be reach driving on the SR657, direction Poggio Mirteto; arrived at the train station, go on towards Rome and at the first roundabout turn right.<\/p>\r\n<p>From the bridge onwards there are several possibilities: directly below the bridge on the left starts a dirt path that you can also get cycling. Right after the bridge there is a small dock to begin a pleasant walk. Getting the direction to Nazzano, you will find the signs for many additional routes in the park \u201cLa Riserva\u201d, having a wonderful extension of 700 hectares of woods and glades, with Poplars, Willows and Alders and many other varieties typical for a path of the Tiber.<\/p>\r\n<p>The walk ends in the Reserve, with the scents of nature and the beauty of the Bassa Sabina.<\/p>\r\n<p>A prelude to many additional discoveries.[\/vc_column_text][vc_tta_tour shape=\"square\" color=\"green\" spacing=\"20\" gap=\"15\" active_section=\"1\" no_fill_content_area=\"true\" title=\"Itinerario\"][vc_tta_section title=\"TAPPA 1\" tab_id=\"1696344647582-eada1aca-2c356fdb-96f7\"][vc_column_text]Starting from Rome, take the A1 toward Orte, exit at Ponzano-Soratte, direction SR657 toward Stimigliano. It is about 7 km, in a little more than 10 minutes you get to the village. The town of Stimigliano is called \"the Gateway to Sabina,\" it is in fact the first town you meet before Rome, exiting the highway. It is gathered around the imposing Baronial Palace of the Orsini family, a work built and enlarged, in various stages, during the 16th century. Paintings by the followers of Taddeo and Federcio Zuccari can be found inside the palace, with images depicting the lives of Joseph and Mary. The beautiful medieval village is embellished by the church of SS. Cosmas and Damian and the church of St. Valentine. From the village it is possible to admire much of the Bassa Sabina and the gentle curves of the Tiber River.[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Indicazioni stradali punto di partenza tappa 1\" style=\"outline\" shape=\"square\" color=\"green\" i_align=\"right\" i_icon_fontawesome=\"fas fa-route\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.com%2Fmaps%2Fplace%2F02048%2BStimigliano%2BRI%2F%4042.2791617%2C12.58497%2C13z%2Fdata%3D!4m22!1m15!4m14!1m6!1m2!1s0x132f10ee2a48fabf%3A0x3c10322da6d471f3!2sStimigliano%2C%2BRI!2m2!1d12.5628575!2d42.3009899!1m6!1m2!1s0x132f0ee62f010f87%3A0xefbad483e0df959a!2sPoggio%2BMirteto%2C%2BRI!2m2!1d12.6876246!2d42.2682668!3m5!1s0x132f10ee2a48fabf%3A0x3c10322da6d471f3!8m2!3d42.3009899!4d12.5628575!16s%252Fg%252F11bc6h2mln%3Fhl%3Dit%26entry%3Dttu|target:_blank\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Vai alla scheda del comune di Stimigliano\" style=\"outline\" shape=\"square\" color=\"warning\" i_align=\"right\" i_icon_fontawesome=\"far fa-file-alt\" add_icon=\"true\" link=\"url:https%3A%2F%2Fgeosabina.it%2Fdestinations%2Fstimigliano%2F\"][\/vc_column_inner][\/vc_row_inner][\/vc_tta_section][vc_tta_section title=\"TAPPA 2\" tab_id=\"1696344647611-95d2120a-89626fdb-96f7\"][vc_column_text]<strong>From Stimigliano we move on to Forano<\/strong>, returning to the SR657 road and leaving the highway on the right, at the first traffic circle, we go up to the village. Forano is a small nucleus that has a very distant history, there is in fact evidence of Sabine settlements as early as the 9th century BC. Starting with the fall of the Roman Empire, the countryside became depopulated and in the centuries to come the town absorbed the identities of the local lords, until it became a Free Commune in 1262. The striking Ducal Palace, built around the 13th century, towers over the ruins of the ancient fortress. Numerous churches: the Holy Trinity and Mary of the Assumption, built in the late 17th century, the 19th-century Waldensian Evangelical Church and the Church of St. Sebastian. Enchanting is the Parco della Rimembranza, dedicated to the fallen soldiers of World War I, dating back to 1925.<\/p>\r\n<p>The small hamlet of <strong>Gavignano<\/strong> is a nucleus, small but archaeologically important; indeed, there are traces of walls from Roman times.[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Indicazioni stradali punto di partenza tappa 2\" style=\"outline\" shape=\"square\" color=\"green\" i_align=\"right\" i_icon_fontawesome=\"fas fa-route\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.com%2Fmaps%2Fplace%2F02044%2BForano%2BRI%2F%4042.2998686%2C12.5847013%2C15z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132f1046b8fcd0d7%3A0xed04d45627f43e2c!8m2!3d42.2952897!4d12.5951416!16zL20vMGdtNWdq%3Fhl%3Dit%26entry%3Dttu|target:_blank\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Vai alla scheda del comune di Tarano\" style=\"outline\" shape=\"square\" color=\"warning\" i_align=\"right\" i_icon_fontawesome=\"far fa-file-alt\" add_icon=\"true\" link=\"url:https%3A%2F%2Fgeosabina.it%2Fdestinations%2Ftarano%2F\"][\/vc_column_inner][\/vc_row_inner][\/vc_tta_section][vc_tta_section title=\"TAPPA 3\" tab_id=\"1696344891500-aa2c7edd-9eb66fdb-96f7\"][vc_column_text]Our itinerary draws to a close, concluding in the fascinating embraces of nature in the <strong>Tiber Farfa Oasis<\/strong>. Still on SR657, heading towards Poggio Mirteto; having arrived at the train station, continue towards Rome and at the first traffic circle turn decisively right. From the bridge onwards there are various possibilities: immediately under the bridge on the left begins a dirt path that can also be traveled by bicycle. After the bridge, mirrored, is a small dock from which to begin a pleasant walk. If you continue further, in the direction of Nazzano, you will be able to find signs for other paths in the park.The Reserve is an admirable extension of 700 hectares of woods and clearings, with Poplars, Willows and Alders and many other varieties that follow the path of the Tiber.<\/p>\r\n<p>The walk ends in the Reserve, with the scents of nature and the beauty of the <strong>Bassa Sabina<\/strong>. A taste that is a prelude to many more discoveries.[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Indicazioni stradali punto di partenza tappa 3\" style=\"outline\" shape=\"square\" color=\"green\" i_align=\"right\" i_icon_fontawesome=\"fas fa-route\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.com%2Fmaps%2F%4042.2356096%2C12.6270884%2C3a%2C75y%2C97.39h%2C81.49t%2Fdata%3D!3m6!1e1!3m4!1sBcppBg4eVpVYJVtH_rCM9g!2e0!7i13312!8i6656%3Fhl%3Dit%26entry%3Dttu|target:_blank\"][\/vc_column_inner][vc_column_inner width=\"1\/2\" offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_btn title=\"Vai alla scheda del Santuario di Vescovio\" style=\"outline\" shape=\"square\" color=\"warning\" i_align=\"right\" i_icon_fontawesome=\"far fa-file-alt\" add_icon=\"true\" link=\"url:https%3A%2F%2Fgeosabina.it%2Faltri-comuni%2Fvescovio-area-archeologica-forum-novum-e-santuario%2F\"][\/vc_column_inner][\/vc_row_inner][\/vc_tta_section][\/vc_tta_tour][vc_row_inner el_class=\"video_app\"][vc_column_inner offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"4\" slider_loop=\"yes\" slider_autoplay=\"yes\" slider_navigation=\"yes\" slider_pagination=\"yes\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"25px\"][vc_empty_space height=\"25px\"][vc_column_text]<\/p>\r\n<h2><strong>Video<\/strong><\/h2>\r\n<p>[\/vc_column_text][vc_empty_space height=\"25px\"][vc_video link=\"https:\/\/youtu.be\/vF4cAi5cPrU\"][vc_empty_space height=\"25px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]<\/p>\r\n","post_title":"Stimigliano \u2013 Forano e Oasi Tevere Farfa","post_link":"https:\/\/geosabina.it\/en\/routes\/stimigliano-forano-e-oasi-tevere-farfa\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Stimigliano \u2013 Forano e Oasi Tevere Farfa\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/07\/itinerari-logo-300x191.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_thumbnail_id%":"6921","%_edit_lock%":"1696929351:6","%_wpb_shortcodes_custom_css%":".vc_custom_1696325961236{padding: 20px !important;}.vc_custom_1696326193021{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696326261455{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696326280823{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696326295906{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696929178272{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":509,\"to_translate\":{\"en\":509}}","%_wpml_location_migration_done%":"1","%_wpgmp_location_address%":"02048 Stimigliano RI, Italia","%_wpgmp_location_city%":"Stimigliano","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.3009899","%_wpgmp_metabox_longitude%":"12.5628575","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"3\";i:1;s:2:\"16\";i:2;s:2:\"17\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:2:\"19\";i:1;s:2:\"22\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_wpb_post_custom_css%":".itinerari {\r\n    width:100%;\r\n    max-width:300px;\r\n}","%_dp_original%":"6908","%_edit_last%":"6","%_last_translation_edit_mode%":"native-editor","%_yoast_wpseo_focuskw%":"Stimigliano \u2013 Forano e Oasi Tevere Farfa","%_yoast_wpseo_metadesc%":"Nella campagna sabina le bellezze si alternano tra il naturale e l\u2019artistico. In particolare in questa proposta di itinerario, si prevedono tre incantevoli paesi che si affacciano sulla vallata del Tevere e dai quali si raggiunge la meravigliosa Oasi Tevere Farfa.","%_yoast_wpseo_linkdex%":"58","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"7","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=translation_priority":"Optional, Optional"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari-artistici_sito.png"},"id":6958,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari_sito.png","name":"Itinerari Naturalistici \/ Nature Trails","id":"19","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari-artistici_sito.png","name":"Itinerari Artistici \/ Artistic Itineraries","id":"22","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Towards Tancia Mount in Mountain Bike","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Towards Tancia Mount in Mountain Bike\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari-naturalistici-anteprima-300x191.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/en\/routes\/towards-tancia-mount-in-mtb\/\" class=\"fc-post-link\">Towards Tancia Mount in Mountain Bike<\/a><\/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":"02034 Bocchignano RI, Italia","location":{"lat":"42.2555611","city":"Montopoli di Sabina","state":"Lazio","country":"Italia","lng":"12.7027399","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/en\/routes\/towards-tancia-mount-in-mtb\/","zoom":18,"extra_fields":{"post_excerpt":"","post_content":"<p>[vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/4\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-sm vc_hidden-xs\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_single_image image=\"9190\" img_size=\"full\" alignment=\"center\" onclick=\"custom_link\" el_class=\"itinerari\" link=\"https:\/\/geosabina.it\/itinerari\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner el_class=\"info_app\" css=\".vc_custom_1696325961236{padding: 20px !important;}\"][vc_column_inner][vc_column_text el_class=\"info-point\"]<\/p>\r\n<h4 style=\"padding-top: 5px;\"><strong>Tipologia<\/strong><\/h4>\r\n<p>[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696326193021{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Percorso in Auto e a Piedi<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]<\/p>\r\n<h4 style=\"padding-top: 5px;\"><strong>Numero Tappe<\/strong><\/h4>\r\n<p>[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1697449209136{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">2<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]<\/p>\r\n<h4 style=\"padding-top: 5px;\"><strong>Durata<\/strong><\/h4>\r\n<p>[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1697449330472{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">About 4 hours<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]<\/p>\r\n<h4 style=\"padding-top: 5px;\"><strong>Difficolt\u00e0<\/strong><\/h4>\r\n<p>[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1697449301607{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Media<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]<\/p>\r\n<h4 style=\"padding-top: 5px;\"><strong>Punto di Partenza<\/strong><\/h4>\r\n<p>[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1697449315192{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Bocchignano<\/span><\/strong>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"3\/4\"][vc_empty_space height=\"40px\"][vc_column_text]<\/p>\r\n<h2>Towards Tancia Mount <strong>in Mountain Bike<\/strong><\/h2>\r\n<p>[\/vc_column_text][vc_column_text css=\".vc_custom_1697449063111{margin-top: -20px !important;}\"]<\/p>\r\n<h5>Itinerario Naturalistico<\/h5>\r\n<p>[\/vc_column_text][vc_empty_space height=\"40px\"][vc_column_text]<strong>DESCRIPTION<\/strong><br \/>\r\nAverage difficultiy route through the Sabine mountains, and between Salisano Poggio Catino, passing through the Tancia Mount. The route alternates between dirt and paved tracks, poorly popular.<\/p>\r\n<p><strong>HOW TO REACH US<\/strong><br \/>\r\nTo reach Bocchignano you should run the Salaria Way for 35.9 km, then turns to Poggio Mirteto (Sp 313). At km 10.2, in Colonnetta town precisely, turn right (Sp 42) going towards Salisano. Passi through the Granari village , towards Farfa, and turn left to Bocchignano at the km 14, properly.<\/p>\r\n<p>Km 3.0 to 391 masl \u2013 Km 0.0 to 175 masl<br \/>\r\nThe starting point is the church on the corner getting the road for Salisano.<br \/>\r\nTake the dirt uphill \u2013 via piedimonte \u2013 on the right of the church going up to St.Valentine in Poggio Mirteto<\/p>\r\n<p>Km 0.6 to 245 masl<br \/>\r\nGo left uphill alternating steep cemented ramps and stretches of dirt road.<\/p>\r\n<p>At km 1 you will pass a gate<br \/>\r\nKm 1.1 to 285 masl<br \/>\r\nWhen cross a home, go on keeping the left<\/p>\r\n<p>Km 2.6 to 364 masl<br \/>\r\nAt the junction, turn left on asphalt path<\/p>\r\n<p>Overcome a steep ramp intersecting another road and turn right, there. After 900 m turn right, where the asphalt changes into a the dirt path in the woods<\/p>\r\n<p>Km 6.1 to 636 masl<br \/>\r\nHere you will find a fork marked by a big wooden quite illegible today. Go on the right<\/p>\r\n<p>Km 7.3 to 634 masl<br \/>\r\nAt the fork, go left<\/p>\r\n<p>Km 7.6 to 648 masl<br \/>\r\nCrossing \u201cCasale Ferri\u201d you will face up an additional dirt path. Turn left and ride for 1 km<\/p>\r\n<p>Km 8.7 to 626 masl<br \/>\r\nOnce on the road, turn right on asphalt. In first kilometers you will face ups and downs.<\/p>\r\n<p>After passing a bridge \u2013 where you can take a detour on foot to St. Michael\u2019s Cave (15 min) \u2013 the slope is stronger.<\/p>\r\n<p>Km 11.7 to 784 masl<br \/>\r\nOnce riched the saddle, the highest point of the day, turn right on a dirt road passing by the old Osteria del Tancia, now adapted to a hostel. As written on the signs , an important way of communication until last century.<\/p>\r\n<p>12.1 km 792 m<br \/>\r\nAt the fork take the dirt on the right. You are still going up before the long descent towards Salisano. You will pass next to a farmhouse with picnic area, enter the wood there. Get again the asphalt way to the country.<\/p>\r\n<p>Km 19.2 to 416 masl<br \/>\r\nAt the crossroads, you will come into town and turn left downhill.<\/p>\r\n<p>Km 19.7 to 389 meters above sea level<br \/>\r\nOnce on the road, turn right. In 8 km you will quickly return to Bocchignano. Should you want to avoid the truck traffic, especially the heavy one on weekdays, best to move forward as hereinafter described.<\/p>\r\n<p>Km 22.1 to 291 masl<br \/>\r\nLeave the main road turning left on Via Roccabaldesca downhill<\/p>\r\n<p>Km 22.2 to 288 masl<br \/>\r\nAfter a few meters turn right onto Via Rocca. A couple of steep descending will lead you in the plain<\/p>\r\n<p>Km 25.9 to 112 masl<br \/>\r\nYou are now on the main road. Turn right and slightly uphill to be back to Bocchignano in a couple of km<\/p>\r\n<p>[\/vc_column_text][vc_empty_space height=\"40px\"][vc_btn title=\"Get directions to your starting point\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.com%2Fmaps%2Fdir%2FBocchignano%2C%2BRieti%2F42.2550455%2C12.7029108%2F%4042.2548569%2C12.7012942%2C17.75z%2Fdata%3D!4m8!4m7!1m5!1m1!1s0x132f0ec7e4c0e255%3A0xa094f9d5b9f18d0!2m2!1d12.7027399!2d42.2555611!1m0%3Fhl%3Dit%26entry%3Dttu\" el_id=\"bottoneindicazioni\"][vc_row_inner el_class=\"video_app\"][vc_column_inner offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"4\" slider_loop=\"yes\" slider_autoplay=\"yes\" slider_navigation=\"yes\" slider_pagination=\"yes\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"25px\"][vc_empty_space height=\"25px\"][vc_column_text]<\/p>\r\n<h2><strong>Video<\/strong><\/h2>\r\n<p>[\/vc_column_text][vc_empty_space height=\"25px\"][vc_video link=\"https:\/\/youtu.be\/vF4cAi5cPrU\"][vc_empty_space height=\"25px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]<\/p>\r\n","post_title":"Towards Tancia Mount in Mountain Bike","post_link":"https:\/\/geosabina.it\/en\/routes\/towards-tancia-mount-in-mtb\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Towards Tancia Mount in Mountain Bike\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari-naturalistici-anteprima-300x191.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_thumbnail_id%":"9196","%_edit_lock%":"1697450036:6","%_wpb_shortcodes_custom_css%":".vc_custom_1696325961236{padding: 20px !important;}.vc_custom_1696326193021{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1697449209136{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1697449330472{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1697449301607{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1697449315192{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1697449063111{margin-top: -20px !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":612,\"to_translate\":{\"en\":612}}","%_wpml_location_migration_done%":"1","%_wpgmp_location_address%":"02034 Bocchignano RI, Italia","%_wpgmp_location_city%":"Montopoli di Sabina","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2555611","%_wpgmp_metabox_longitude%":"12.7027399","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"3\";i:1;s:2:\"16\";i:2;s:2:\"17\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"19\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_wpb_post_custom_css%":".itinerari {\r\n    width:100%;\r\n    max-width:300px;\r\n}","%_dp_original%":"6930","%_edit_last%":"6","%_last_translation_edit_mode%":"native-editor","%_yoast_wpseo_focuskw%":"Towards Tancia Mount in Mountain Bike","%_yoast_wpseo_metadesc%":"Welcome to a mountain biking adventure through the picturesque mountains of Sabina, a hidden treasure in the heart of Italy.","%_yoast_wpseo_linkdex%":"62","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=translation_priority":"Optional, Optional"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari_sito.png"},"id":6953,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari_sito.png","name":"Itinerari Naturalistici \/ Nature Trails","id":"19","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Colle Cosimo, Colle Capanne e Monte Morrone","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Colle Cosimo, Colle Capanne e Monte Morrone\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari-naturalistici-anteprima-300x191.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/en\/routes\/colle-cosimo-colle-capanne-e-monte-morrone\/\" class=\"fc-post-link\">Colle Cosimo, Colle Capanne e Monte Morrone<\/a><\/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":"02047 Poggio Mirteto RI, Italia","location":{"lat":"42.2682668","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.6876246","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/en\/routes\/colle-cosimo-colle-capanne-e-monte-morrone\/","zoom":18,"extra_fields":{"post_excerpt":"","post_content":"[vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/4\"][vc_empty_space height=\"20px\"][vc_single_image image=\"9190\" img_size=\"full\" alignment=\"center\" onclick=\"custom_link\" el_class=\"itinerari\" link=\"https:\/\/geosabina.it\/itinerari\/\"][vc_empty_space height=\"20px\"][vc_row_inner el_class=\"info_app\" css=\".vc_custom_1696325961236{padding: 20px !important;}\"][vc_column_inner][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\"><strong>Tipologia<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696589312644{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Car and Walking Route<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\"><strong>Numero Tappe<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696589319862{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">1<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\"><strong>Durata<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696589336563{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">2.30 h<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\"><strong>Difficolt\u00e0<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696589351895{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Easy<\/span><\/strong>.[\/vc_column_text][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\"><strong>Punto di Partenza<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696589364603{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Poggio Mirteto<\/span><\/strong>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"3\/4\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Colle Cosimo, Colle Capanne e <strong>Monte Morrone<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_column_text]The nature in Sabine Region is a wonderful one, wild and untouched.\r\n\r\nThe small villages around the countryside and the mountains frame the magnificence of the landscape; the seasons are the vivid expression of blooms, here.\r\n\r\nMany hills and some higher ones can be easily seen and reached by car, to go on walking and going deeply among paths and woods. In this selection of mountain itineraries, we have provided some intriguing routes giving inputs to a planty of possibilities.\r\n\r\nThe strength of the Sabine landscapes is unprecedent.It gives breath and relief, as if it was a cure for the progress and daily life deseases, it slows down and looks around as a color and lightness strong desire.\r\n\r\nThe first itinerary includes two hills and a mountain: Colle Cosimo, Colle Capanne and Monte Morrone.\r\n\r\nVertical drop: 270 meters (approx.)\r\nDifficulty: easy walk through woods and rocks\r\nDress code: boots, jacket, hat, waterproof clothing (any equipments needed), water\r\n\r\nThe hills involved are the real \u201cfront door\u201d on the side SW. Very interesting itinerary because of the totality of the climatic zones. Although well-shaded it is not recommended in summer or in times of drought. No fountains.\r\n\r\n<strong>Itinerary<\/strong>\r\n\r\nDriving from Poggio Mirteto you climb to San Valentino hill, along the paved road.\r\n\r\nWhen the paved road ends, just on the right, a dirt road starts and there you can park your car and start walking. The altitude is 494 m, here.\r\n\r\nWalk on the dirt road for a few dozen meters. On the left you will see a stony path uphill, within a forest of oaks.\r\n\r\nTake the path and after 15 minutes walking you will reach a grassy saddle. Going on downhill, always on the stony path, you will reach a ditch. Cross the ditch and you will come to a crossroads. Take the middle path stlanting up towards the left and after 30 minutes you cross the dirt road you left early.\r\n\r\nRight after on the left, a large mule path climbs towards the south ridge of Colle Capanne.\r\n\r\nWatching southwards you can admire the Tiber valley and you can see the chain of Lecretili Mountains.\r\n\r\nAt the top of Colle Capanne (50 minutes later, more or less), walk down to the west following a fence and leaving the wooded spot on your right. You come to a wide open area and continue through clearings, woodlands and mixed stain. You will finallt reach the Morrone Mountain foresummit. Walking for an hour and twenty minutes more, you will get to the Morrone Mountain real top.\r\n\r\n(Special thanks to Alberto Casazza, who contributed to the realization of this route with his precious book on Sabine routes ).[\/vc_column_text][vc_row_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Indicazioni stradali punto di partenza tappa 1\" style=\"outline\" shape=\"square\" color=\"green\" i_align=\"right\" i_icon_fontawesome=\"fas fa-route\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.com%2Fmaps%2Fplace%2F02047%2BSan%2BValentino%2BRI%2F%4042.2717815%2C12.6957311%2C18.5z%2Fdata%3D!4m22!1m15!4m14!1m6!1m2!1s0x132f0edee08f08f9%3A0x30bd23359d9d2a39!2sSan%2BValentino%2C%2BPoggio%2BMirteto%2BRI!2m2!1d12.6951999!2d42.2718755!1m6!1m2!1s0x132f0eef47bbeb93%3A0x65a394f287fe7819!2sComune%2BDi%2BPoggio%2BMirteto%2C%2BPiazza%2BMartiri%2Bdella%2BLibert%25C3%25A0%2C%2B40%2C%2B02047%2BPoggio%2BMirteto%2BRI!2m2!1d12.6838721!2d42.2644455!3m5!1s0x132f0edee08f08f9%3A0x30bd23359d9d2a39!8m2!3d42.2718755!4d12.6951999!16s%252Fg%252F119vsx9_q%3Fhl%3Dit%26entry%3Dttu|target:_blank\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Vai alla scheda del comune di Poggio Mirteto \" style=\"outline\" shape=\"square\" color=\"warning\" i_align=\"right\" i_icon_fontawesome=\"far fa-file-alt\" add_icon=\"true\" link=\"url:https%3A%2F%2Fgeosabina.it%2Fdestinations%2Fpoggio-mirteto%2F\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner el_class=\"video_app\"][vc_column_inner offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"4\" slider_loop=\"yes\" slider_autoplay=\"yes\" slider_navigation=\"yes\" slider_pagination=\"yes\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"25px\"][vc_empty_space height=\"25px\"][vc_column_text]\r\n<h2><strong>Video<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"25px\"][vc_video link=\"https:\/\/youtu.be\/vF4cAi5cPrU\"][vc_empty_space height=\"25px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Colle Cosimo, Colle Capanne e Monte Morrone","post_link":"https:\/\/geosabina.it\/en\/routes\/colle-cosimo-colle-capanne-e-monte-morrone\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Colle Cosimo, Colle Capanne e Monte Morrone\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari-naturalistici-anteprima-300x191.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_edit_lock%":"1696589374:6","%_wpb_shortcodes_custom_css%":".vc_custom_1696325961236{padding: 20px !important;}.vc_custom_1696589312644{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696589319862{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696589336563{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696589351895{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696589364603{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":502,\"to_translate\":{\"en\":502}}","%_wpml_location_migration_done%":"1","%_wpgmp_location_address%":"02047 Poggio Mirteto RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2682668","%_wpgmp_metabox_longitude%":"12.6876246","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"3\";i:1;s:2:\"16\";i:2;s:2:\"17\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"19\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_wpb_post_custom_css%":".itinerari {\r\n    width:100%;\r\n    max-width:300px;\r\n}","%_dp_original%":"6930","%_edit_last%":"6","%_last_translation_edit_mode%":"native-editor","%_thumbnail_id%":"9196","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Colle Cosimo, Colle Capanne e Monte Morrone","%_yoast_wpseo_metadesc%":"The nature of the Sabine is a wonderful nature, at times wild and unspoiled, the small villages that surround the countryside and mountains, frame the magnificence of the landscape","%_yoast_wpseo_linkdex%":"63","taxonomy=translation_priority":"Optional, Optional"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari_sito.png"},"id":6946,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari_sito.png","name":"Itinerari Naturalistici \/ Nature Trails","id":"19","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Toffia, Abbazia di Farfa, Montopoli di Sabina, Poggio Mirteto","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Toffia, Abbazia di Farfa, Montopoli di Sabina, Poggio Mirteto\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/07\/itinerari-logo-300x191.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/en\/toffia-abbazia-di-farfa-montopoli-di-sabina-poggio-mirteto\/\" class=\"fc-post-link\">Toffia, Abbazia di Farfa, Montopoli di Sabina, Poggio Mirteto<\/a><\/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":"02039 Toffia RI, Italia","location":{"lat":"42.2124537","city":"Toffia","state":"Lazio","country":"Italia","lng":"12.753571","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/en\/toffia-abbazia-di-farfa-montopoli-di-sabina-poggio-mirteto\/","zoom":18,"extra_fields":{"post_excerpt":"","post_content":"[vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/4\"][vc_empty_space height=\"40px\"][vc_single_image image=\"6859\" img_size=\"full\" onclick=\"custom_link\" el_class=\"itinerari\" link=\"https:\/\/geosabina.it\/itinerari\/\"][vc_empty_space height=\"25px\"][vc_row_inner el_class=\"info_app\"][vc_column_inner][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Punto di Partenza<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1659011373623{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Toffia, RI[\/vc_column_text][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Durata del Tour<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1652104470788{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Non definito[\/vc_column_text][vc_column_text css=\".vc_custom_1651915077990{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"][\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"3\/4\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Toffia, Abbazia di Farfa, <strong>Montopoli di Sabina, Poggio Mirteto<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_column_text]L\u2019itinerario che vogliamo proporvi \u00e8 ricco di suggestioni e borghi meravigliosi, incorniciati dalla campagna unica della sabina medievale.\r\n\r\nIl nostro viaggio comincia da un paese piccolo, un borgo arroccato che si affaccia su splendidi paesaggi, Toffia. Da Roma si raggiunge facilmente attraverso la Salaria, sino ad arrivare all\u2019uscita Rieti\/Casali di Poggio Nativo, al Km 49,2, in direzione Toffia, su Via Farense; in circa 8 minuti si arriva al paese.\r\n\r\nToffia \u00e8 un paese dell\u2019Alto Medioevo la cui prima notizia risale al 940. Nel 1300 il castello acquis\u00ec una grande importanza e divenne la seconda sede del vescovo di Sabina. Nel 1400 fu ampliata la cinta muraria e venne costruita la Rocca e la Porta Maggiore. Il Palazzo degli Orsini risale al secolo XV. La Chiesa di San Lorenzo, del X secolo, e la chiesa parrocchiale del secolo XVI, intitolata a S. Maria Nuova, meritano sicuramente una visita.\r\n\r\nDa Toffia si prosegue il nostro tour verso l\u2019Abbazia di Farfa, si prende la Via Farense in direzione est, indicazioni per Farfa. Le origini dell\u2019Abbazia sono misteriose, ma sicuramente il cenobio venne fondato nel VI secolo da S. Lorenzo Siro.\r\n\r\nNei secoli i frati benedettini proseguirono l\u2019opera di arricchimento della costruzione e del borgo. Nel secolo IX, a causa delle incursioni dei Saraceni, l\u2019Abbazia fu devastata, ma dopo la loro sconfitta l\u2019Abate Ratfredo la ricostru\u00ec. Nei secoli successivi la sua ricostruzione la port\u00f2 a diventare la \u201cregina\u201d incontrastata dei luoghi di culto, ampliando i suoi possedimenti anche fuori dalla sabina.\r\n\r\nLa Chiesa Abbaziale risale alla met\u00e0 del secolo XV, ed \u00e8 preceduta da un cortile in stile Romanico del \u2018200. L\u2019interno \u00e8 a tre navate e si pu\u00f2 ammirare un pregevole Giudizio Universale, attribuito al pittore fiammingo Hendrick van der Broek. Negli altari minori si possono ammirare tele seicentesche di buona fattura. Oltre alla visita, immancabile, della chiesa, il borgo offre interessanti spunti d\u2019interesse, con le botteghe degli artigiani, in perfetto stile medievale.\r\n\r\nProseguendo verso Granica, per Via Mirtense, si arriva a un bivio, si svolta a sinistra verso Montopoli di Sabina, si prende Via Granica sud, direzione Granari. Si raggiunge dopo pochi km il paese di Montopoli.\r\n\r\nCome tracce di insediamenti umani, il territorio di Montopoli \u00e8 tra i pi\u00f9 antichi della Sabina. In alcune zone sono stati rinvenuti resti appartenenti al Paleolitico Superiore.\r\n\r\nSicuramente una delle meraviglie del territorio montopolese \u00e8 la villa Terenzio Varrone, detta anche \u201cI Casoni\u201d, splendida costruzione risalente al II secolo aC.\r\n\r\nL\u2019accesso al paese \u00e8 attraverso la Porta di Via dei Portici, che introduce all\u2019antico borgo. Immancabile una visita alla Chiesa di S. Maria degli Angeli, che conserva affreschi di Vincenzo Manenti e decorazioni barocche. Nella Chiesa di S. Maria delle Grazie \u00e8 conservata una Madonna in trono col bambino. La chiesa parrocchiale, dedicata a S. Michele Arcangelo, opera del XVII secolo, con una pregevole torre campanaria \u00e8 tappa a cui dedicare sicuramente del tempo.\r\n\r\nIl nostro itinerario volge al termine, approdando all\u2019ultimo paese del percorso, Poggio Mirteto, il paese pi\u00f9 grande della Bassa Sabina.\r\n\r\nPodium Myrtetum, fondato verso la prima met\u00e0 del \u2018200, fu rocca strategica di alcuni feudatari della zona; infatti la sua posizione favoriva la difensiva. Inizialmente fu possedimento dell\u2019Abbazia di Farfa, nel \u2018500 fu parte dei beni dei Farnese per arrivare infine allo Stato Pontificio. Nel 1867 la sua banda, proprio al seguito di Giuseppe Garibaldi, partecip\u00f2 alla Campagna dell\u2019Agro Romano.\r\n\r\nE\u2019 un paese ricco di storia, anche durante il periodo della seconda guerra mondiale. Molti abitanti di Poggio Mirteto infatti parteciparono attivamente alla resistenza al nazi fascismo.\r\n\r\nL\u2019attuale abitato \u00e8 circoscritto in due parti dalla Porta Farnese \u2013 dentro e fuori le mura \u2013 importante ingresso che introduce al vero e proprio castello. Sulla porta \u00e8 visibile il simbolo araldico della casata. All\u2019interno delle antiche mura, di epoca trecentesca, si possono ammirare il Palazzo Abbaziale e la splendida Torre dell\u2019Orologio, oltre all\u2019intrico affascinante dei piccoli viottoli che si affacciano sulla vallata.\r\n\r\nAl di fuori della porta, nella piazza Martiri della Libert\u00e0, l\u2019imponente Chiesa Cattedrale, da visitare assolutamente. Spiccano nella cattedrale a tre navate, la Madonna in trono col bambino, un battesimo di Cristo, un Transito di S. Giuseppe.\r\n\r\nAltra Chiesa da visitare \u00e8 la Chiesa di San Rocco e la Chiesa di San Paolo.\r\n\r\nMolte sono le ville rustiche romane intorno a Poggio Mirteto, importante \u00e8 la Villa detta I Bagni di Lucilla.\r\n\r\nIl nostro percorso \u00e8 terminato. Poggio Mirteto chiude un itinerario importante \u00e8 impegnativo, sia dal punto di vista artistico, sia dal punto di vista delle distanze. La sabina accoglie un vasto territorio, ricchissimo e variegato, un itinerario \u00e8 un modo per contenere tanta bellezza, ma i confini sono ampi e si spera sempre che i nostri consigli possano essere utilizzati come spunti per pi\u00f9 grandi viaggi e curiosit\u00e0[\/vc_column_text][vc_row_inner el_class=\"video_app\"][vc_column_inner offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"4\" slider_loop=\"yes\" slider_autoplay=\"yes\" slider_navigation=\"yes\" slider_pagination=\"yes\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"25px\"][vc_empty_space height=\"25px\"][vc_column_text]\r\n<h2><strong>Video<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"25px\"][vc_video link=\"https:\/\/youtu.be\/vF4cAi5cPrU\"][vc_empty_space height=\"25px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Toffia, Abbazia di Farfa, Montopoli di Sabina, Poggio Mirteto","post_link":"https:\/\/geosabina.it\/en\/toffia-abbazia-di-farfa-montopoli-di-sabina-poggio-mirteto\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Toffia, Abbazia di Farfa, Montopoli di Sabina, Poggio Mirteto\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/07\/itinerari-logo-300x191.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1659011373623{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1652104470788{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1651915077990{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":830,\"to_translate\":{\"it\":830}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"02039 Toffia RI, Italia","%_wpgmp_location_city%":"Toffia","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2124537","%_wpgmp_metabox_longitude%":"12.753571","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"3\";i:1;s:2:\"16\";i:2;s:2:\"17\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"22\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_thumbnail_id%":"6920","%_wpb_post_custom_css%":".itinerari {\r\n    width:100%;\r\n    max-width:300px;\r\n}","%_dp_original%":"6908","%_edit_lock%":"1659011314:2","%_edit_last%":"2","taxonomy=translation_priority":"Optional"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari-artistici_sito.png"},"id":6936,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari-artistici_sito.png","name":"Itinerari Artistici \/ Artistic Itineraries","id":"22","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"In the Tevere Farfa nature reserve by mountain bike","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 the Tevere Farfa nature reserve by mountain bike\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari-naturalistici-anteprima-300x191.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/en\/routes\/in-the-tevere-farfa-nature-reserve-by-mountain-bike\/\" class=\"fc-post-link\">In the Tevere Farfa nature reserve by mountain bike<\/a><\/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":"00060 Ponzano Romano RM, Italia","location":{"lat":"42.2559994","city":"Ponzano Romano","state":"Lazio","country":"Italia","lng":"12.5691964","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/en\/routes\/in-the-tevere-farfa-nature-reserve-by-mountain-bike\/","zoom":18,"extra_fields":{"post_excerpt":"","post_content":"[vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/4\"][vc_empty_space height=\"40px\"][vc_single_image image=\"6859\" img_size=\"full\" onclick=\"custom_link\" el_class=\"itinerari\" link=\"https:\/\/geosabina.it\/en\/routes\/\"][vc_empty_space height=\"25px\"][vc_row_inner el_class=\"info_app\"][vc_column_inner][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Start Point<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1659010565775{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Casello A1 Ponzano Romano[\/vc_column_text][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Duration<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1659010597607{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]1h 45m[\/vc_column_text][vc_column_text css=\".vc_custom_1651915077990{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"][\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"3\/4\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>In the Tevere Farfa nature reserve <strong>by Mountain Bike<\/strong><\/h2>\r\n[\/vc_column_text][vc_column_text css=\".vc_custom_1696951646334{margin-top: -20px !important;}\"]\r\n<h5>Itinerario Naturalistico<\/h5>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_column_text]Distance from Rome: 50 km\r\nLength: 28 km\r\nTotal ascent: 290 m\r\nMaximum altitude: 210 meters above sea level\r\nDirt road: 65%\r\n\r\nEnchanting route in the Tiber valley north of Rome; fluvial environment of the Tevere Farfa nature reserve, with its beauties and its wild charm. Physical effort limited to the steep climb that leads to the village of Nazzano. In case of rain, the itinerary can still be pedaled, the only drawback being mud.\r\n\r\nHow to get\r\nTake the A1 motorway northwards and exit at Ponzano - Soratte. Immediately after the toll booth, turn right for 200 m up to a square in correspondence with the provincial road to Ponzano where it is possible to stop.\r\nFor those wishing to halfway through the route, it passes near the Monte Libretti station served by urban trains on which the transport of bicycles is allowed\r\n\r\nKm 0.0 - 35 masl\r\nFrom the square at the exit of the toll booth, take the provincial road to Ponzano \/ Nazzano \/ Torrita Tiberina\r\n\r\nKm 1.1 - 35 masl\r\nAt a petrol and methane station, leave the provincial road and turn left\r\n\r\nKm 1,8 - 35 masl\r\nAt the crossroads continue on the asphalt to the right. After 400 m, at an intersection, go straight on. At km 3.1 the road becomes a dirt road and at km 3.6 you are on the edge of the river that you follow along its course\r\n\r\nKm 4,7 30 - above sea level\r\nThe main dirt road turns right towards Filacciano. We continue straight through the cultivated fields in a bend in the river\r\n\r\nKm 6.2 - 30 masl\r\nOnce you reach the river, turn right\r\n\r\nKm 7.1 - 32 masl\r\nAt the intersection we turn left. At km 8.8 we turn right onto the main track\r\n\r\nKm 9.6 - 30 masl\r\nAt a dilapidated house, before reaching the large pipes of the Peschiera aqueduct, turn right uphill on asphalt\r\n\r\nKm 9.9 - 55 masl\r\nTake the provincial road downhill for 700 m\r\n\r\nKm 10.6 - 30 masl\r\nWe take the small road downhill immediately after turning right along the river The provincial road instead continues with a bridge over the river and reaches after about 1 km the station of Poggio Mirteto scalo from where those who use the train can start the route\r\n\r\nKm 11.2 - 30 masl\r\nContinue straight on the wide dirt road along the river. The numerous signs remind us that we are inside the Tiber Farfa natural park. After 5 km, at an old ferry dock, the road turns right becoming asphalted and starting to climb\r\n\r\nKm 16.9 - 30 masl\r\nIn correspondence of a large parking lot we take the slope to the right very calmly; 1 km awaits us at 15%\r\n\r\nKm 18,0 - 163 masl\r\nAt the end of the most demanding stretch of the day, turn left following the signs for Rome \/ A1 motorway, passing the crossroads for Torrita Tiberina (km 19.0) and for Ponzano (km 19.1)\r\n\r\nKm 19.9 - 197 meters above sea level\r\nLeave the provincial road 15 \/ a at km 32,400 turning right for Civitella and after 100 m turn right again following the signs for S. Francesco. Stay on Via S. Francesco for 2 km, ignoring the crossroads you meet\r\n\r\nKm 21.9 - 205 meters above sea level\r\nIn correspondence of a curve to the right, be careful: the main dirt road continues towards S.francesco, we take the small road on the left which immediately begins to descend becoming, after a house, asphalted.\r\n\r\nKm 23.3 - 83 masl\r\nTurn right and then continue along the embankment of the motorway, ignoring the side deviations on a partially paved surface. After about 3 km a large waste bin and the highway underpass bring us back to civilization\r\n\r\nKm 26.4 - 35 masl\r\nOn the provincial road we turn left to return, in 1.3 km, to the starting point.\r\nFor those who wish, walking 300 m towards Ponzano, it is possible to visit the beautiful Romanesque church of S.Andrea in Flumine\r\n\r\n(Thanks to Paola and Gino for their precious contribution)[\/vc_column_text][vc_empty_space height=\"25px\"][vc_btn title=\"Go to start Point\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.com%2Fmaps%2Fplace%2FCasello%2BA1%2BPonzano%2BRomano%252F%2BSoratte%2F%4042.2705401%2C12.5497132%2C15.5z%2Fdata%3D!4m14!1m7!3m6!1s0x132f11eb7acff6ff%3A0x5ec0195134ce1818!2sCasello%2BA1%2BPonzano%2BRomano%252F%2BSoratte!8m2!3d42.2750246!4d12.543707!16s%252Fg%252F11txgjqbsq!3m5!1s0x132f11eb7acff6ff%3A0x5ec0195134ce1818!8m2!3d42.2750246!4d12.543707!16s%252Fg%252F11txgjqbsq%3Fhl%3Dit%26entry%3Dttu\" el_id=\"bottoneindicazioni\"][vc_row_inner el_class=\"video_app\"][vc_column_inner offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"4\" slider_loop=\"yes\" slider_autoplay=\"yes\" slider_navigation=\"yes\" slider_pagination=\"yes\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"25px\"][vc_empty_space height=\"25px\"][vc_column_text]\r\n<h2><strong>Video<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"25px\"][vc_video link=\"https:\/\/youtu.be\/vF4cAi5cPrU\"][vc_empty_space height=\"25px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"In the Tevere Farfa nature reserve by mountain bike","post_link":"https:\/\/geosabina.it\/en\/routes\/in-the-tevere-farfa-nature-reserve-by-mountain-bike\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"In the Tevere Farfa nature reserve by mountain bike\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari-naturalistici-anteprima-300x191.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_thumbnail_id%":"9196","%_edit_lock%":"1696953725:6","%_wpb_shortcodes_custom_css%":".vc_custom_1659010565775{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1659010597607{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1651915077990{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1696951646334{margin-top: -20px !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":725,\"to_translate\":{\"en\":725}}","%_wpml_location_migration_done%":"1","%_wpgmp_location_address%":"00060 Ponzano Romano RM, Italia","%_wpgmp_location_city%":"Ponzano Romano","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2559994","%_wpgmp_metabox_longitude%":"12.5691964","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"3\";i:1;s:2:\"16\";i:2;s:2:\"17\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"19\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_wpb_post_custom_css%":".itinerari {\r\n    width:100%;\r\n    max-width:300px;\r\n}","%_dp_original%":"6846","%_edit_last%":"6","%_last_translation_edit_mode%":"native-editor","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=translation_priority":"Optional, Optional"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari_sito.png"},"id":6931,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari_sito.png","name":"Itinerari Naturalistici \/ Nature Trails","id":"19","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Monte degli Elci \u2013 Colle di Mezzo","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Monte degli Elci \u2013 Colle di Mezzo\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/07\/itinerari-logo-300x191.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/en\/routes\/monte-degli-elci-colle-di-mezzo\/\" class=\"fc-post-link\">Monte degli Elci \u2013 Colle di Mezzo<\/a><\/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":"Str. degli Inglesi, 02032 Fara in Sabina RI, Italia","location":{"lat":"42.2213591","city":"Fara in Sabina","state":"Lazio","country":"Italia","lng":"12.7184945","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/en\/routes\/monte-degli-elci-colle-di-mezzo\/","zoom":18,"extra_fields":{"post_excerpt":"","post_content":"<p>[vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/4\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-sm vc_hidden-xs\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_single_image image=\"9145\" img_size=\"full\" alignment=\"center\" onclick=\"custom_link\" el_class=\"itinerari\" link=\"https:\/\/geosabina.it\/itinerari\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner el_class=\"info_app\" css=\".vc_custom_1696325961236{padding: 20px !important;}\"][vc_column_inner][vc_column_text el_class=\"info-point\"]<\/p>\r\n<h4 style=\"padding-top: 5px;\"><strong>Tipologia<\/strong><\/h4>\r\n<p>[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696326193021{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Percorso in Auto e a Piedi<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]<\/p>\r\n<h4 style=\"padding-top: 5px;\"><strong>Numero Tappe<\/strong><\/h4>\r\n<p>[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696326261455{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">3<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]<\/p>\r\n<h4 style=\"padding-top: 5px;\"><strong>Durata<\/strong><\/h4>\r\n<p>[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696914562186{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">2 hours (approximately)<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]<\/p>\r\n<h4 style=\"padding-top: 5px;\"><strong>Difficolt\u00e0<\/strong><\/h4>\r\n<p>[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696914408061{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">agile and well-defined path, woods and clearings alternate with rocks<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]<\/p>\r\n<h4 style=\"padding-top: 5px;\"><strong>Punto di Partenza<\/strong><\/h4>\r\n<p>[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696914495167{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Abbazia di Farfa<\/span><\/strong>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"3\/4\"][vc_empty_space height=\"40px\"][vc_column_text]<\/p>\r\n<h2>Monte degli Elci <strong>Colle di Mezzo<\/strong><\/h2>\r\n<p>[\/vc_column_text][vc_column_text css=\".vc_custom_1696332855438{margin-top: -20px !important;}\"]<\/p>\r\n<h5>Itinerario Artistico<\/h5>\r\n<p>[\/vc_column_text][vc_empty_space height=\"40px\"][vc_column_text]Colle di Mezzo and Monte degli Elci (Elci Mount) are the buttresses of the entry to the Sabine south mountains of the chain. Nice and fascinating walk. The first and the last part provide a dense bush; on the contrary, the high altitude parts are sunny and exposed to the winds. It is not recommended during the Summer Season. In the resto of year, lsxcursions and walking are pleasant. On the way, you will enjoy a nice fountain with a picnic area.<\/p>\r\n<p>Vertical drop: 210 meters<\/p>\r\n<p>Dress code suggested: boots and trousers, anoraks (possibly clothing suitable for rain)<\/p>\r\n<p>On the top, wind exposure is significant, and it is strongly recommended an appropriate clothing to temperature changes (several layers of clothing).<\/p>\r\n<p>By car, coming from the Farfa Abbey, right before entering the village of Toffia, turn right and take Via Montagna; be careful, because the road is partially paved and partially gravel.<\/p>\r\n<p>Walk for 2.5 kilometers. After the short paved, go on the dirt way until you will face up a sort of bend on the left, where you can park (495 masl)<\/p>\r\n<p>Now, walk following the road and you will reach a bar (always open) continue on the steep section. Going on the steep way on the left get a short flat stretch for a few hundred meters. After covering a part uphill, close to some signs, turn right on a dirt runway, often muddy, and and go on walkinf for 15 minutes. Walk on penetrating a wooded area halfway on the track then on the marked trail. After 45 minutes walking you will reach a grassy saddle, where you can admire the beautiful views of the Tiber Valley, Rome and the Lucretili Mountains, etc. From the saddle, walk along a grassy ridge covered with limestone hills. We are on top of the Colle di Mezzo, with a 360 degree landscapes view (one hour walk).<\/p>\r\n<p>You can see a wide grassy saddle between two mountains and descends, turning around the top of the Elci Mount, so named for the dense scrub of holm oaks (ancient oaks definition). Returning to the lower part of the saddle you can see a clear path on the right of the ridge, leading to a visible path. Reached the trail, go left. You get to a large area equipped with a fountain. Continuing along the trail, after a few dozen meters, you are back to the way you came.<\/p>\r\n<p>It takes a stroll in the delightful town of Toffia.[\/vc_column_text][vc_row_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Indicazioni stradali punto di partenza tappa 1\" style=\"outline\" shape=\"square\" color=\"green\" i_align=\"right\" i_icon_fontawesome=\"fas fa-route\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.com%2Fmaps%2Fplace%2FAbbazia%2BBenedettina%2Bdi%2BSanta%2BMaria%2Bdi%2BFarfa%2F%4042.2212088%2C12.7177225%2C19.25z%2Fdata%3D!4m22!1m15!4m14!1m6!1m2!1s0x132f0bf73a3d6c07%3A0xf8609d106d61956d!2sAbbazia%2BDi%2BFarfa%2BUff.%2BParr.%2C%2BVia%2Bdi%2BPorta%2BMontopoli%2C%2BFara%2Bin%2BSabina%2C%2BRI!2m2!1d12.7180842!2d42.2212651!1m6!1m2!1s0x132f0ee62f010f87%3A0xefbad483e0df959a!2sPoggio%2BMirteto%2C%2BRI!2m2!1d12.6876246!2d42.2682668!3m5!1s0x132f0bf730d18831%3A0x96074f530401e799!8m2!3d42.220882!4d12.7187574!16zL20vMDkwMXNy%3Fhl%3Dit%26entry%3Dttu|target:_blank\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Vai alla scheda del comune di Toffia\" style=\"outline\" shape=\"square\" color=\"warning\" i_align=\"right\" i_icon_fontawesome=\"far fa-file-alt\" add_icon=\"true\" link=\"url:https%3A%2F%2Fgeosabina.it%2Fdestinations%2Ftoffia%2F\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner el_class=\"video_app\"][vc_column_inner offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"4\" slider_loop=\"yes\" slider_autoplay=\"yes\" slider_navigation=\"yes\" slider_pagination=\"yes\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"25px\"][vc_empty_space height=\"25px\"][vc_column_text]<\/p>\r\n<h2><strong>Video<\/strong><\/h2>\r\n<p>[\/vc_column_text][vc_empty_space height=\"25px\"][vc_video link=\"https:\/\/youtu.be\/vF4cAi5cPrU\"][vc_empty_space height=\"25px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]<\/p>\r\n","post_title":"Monte degli Elci \u2013 Colle di Mezzo","post_link":"https:\/\/geosabina.it\/en\/routes\/monte-degli-elci-colle-di-mezzo\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Monte degli Elci \u2013 Colle di Mezzo\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/07\/itinerari-logo-300x191.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_thumbnail_id%":"6921","%_edit_lock%":"1696929705:6","%_wpb_shortcodes_custom_css%":".vc_custom_1696325961236{padding: 20px !important;}.vc_custom_1696326193021{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696326261455{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696914562186{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696914408061{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696914495167{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696332855438{margin-top: -20px !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":507,\"to_translate\":{\"en\":507}}","%_wpml_location_migration_done%":"1","%_wpgmp_location_address%":"Str. degli Inglesi, 02032 Fara in Sabina RI, Italia","%_wpgmp_location_city%":"Fara in Sabina","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2213591","%_wpgmp_metabox_longitude%":"12.7184945","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"3\";i:1;s:2:\"16\";i:2;s:2:\"17\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"19\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_wpb_post_custom_css%":".itinerari {\r\n    width:100%;\r\n    max-width:300px;\r\n}","%_dp_original%":"6846","%_edit_last%":"6","%_last_translation_edit_mode%":"native-editor","%_yoast_wpseo_focuskw%":"Monte degli Elci Colle di Mezzo","%_yoast_wpseo_metadesc%":"Colle di Mezzo and Monte degli Elci (Elci Mount) are the buttresses of the entry to the Sabine south mountains of the chain. Nice and fascinating walk.","%_yoast_wpseo_linkdex%":"65","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=translation_priority":"Optional, Optional"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari_sito.png"},"id":6914,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari_sito.png","name":"Itinerari Naturalistici \/ Nature Trails","id":"19","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Magliano Sabina, Tarano e Vescovio","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Magliano Sabina, Tarano e Vescovio\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/10\/itinerari-artistici-300x191.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/en\/routes\/magliano-sabina-tarano-e-vescovio\/\" class=\"fc-post-link\">Magliano Sabina, Tarano e Vescovio<\/a><\/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":"02046 Magliano Sabina RI, Italia","location":{"lat":"42.364143","city":"Magliano Sabina","state":"Lazio","country":"Italia","lng":"12.4788065","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/en\/routes\/magliano-sabina-tarano-e-vescovio\/","zoom":18,"extra_fields":{"post_excerpt":"","post_content":"[vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row][vc_column][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Magliano Sabina, <strong>Tarano e Vescovio<\/strong><\/h2>\r\n[\/vc_column_text][vc_column_text css=\".vc_custom_1696496103532{margin-top: -20px !important;}\"]\r\n<h5>Artistic Itinerary<\/h5>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column][\/vc_row][vc_row gap=\"20\" css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/4\" css=\".vc_custom_1696326100559{border-top-width: 10px !important;border-right-width: 10px !important;border-bottom-width: 10px !important;border-left-width: 10px !important;padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;background-color: #f4f4f4 !important;border-left-color: #ffffff !important;border-left-style: solid !important;border-right-color: #ffffff !important;border-right-style: solid !important;border-top-color: #ffffff !important;border-top-style: solid !important;border-bottom-color: #ffffff !important;border-bottom-style: solid !important;}\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-sm vc_hidden-xs\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_single_image image=\"9145\" img_size=\"full\" alignment=\"center\" onclick=\"custom_link\" el_class=\"itinerari\" link=\"https:\/\/geosabina.it\/itinerari\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner el_class=\"info_app\" css=\".vc_custom_1696325961236{padding: 20px !important;}\"][vc_column_inner][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\">Type<\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696326193021{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Percorso in Auto e a Piedi<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\">Number of Stages<\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696326261455{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">3<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\">Duration<\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696326280823{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">1 Giorno<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\">Difficulty<\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696326295906{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Facile<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\">Starting Point<\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696349541619{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Magliano Sabina<\/span><\/strong>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"3\/4\"][vc_column_text]This itinerary can take 1 or even 2 days with an overnight stay, depending very much on the time one has available. The itinerary is very varied and offers the possibility to visit 2 villages, of the Lower Sabina, of great artistic interest as well as the beautiful <strong>Sanctuary of Vescovio<\/strong>.[\/vc_column_text][vc_empty_space height=\"30px\"][vc_tta_tour shape=\"square\" color=\"green\" spacing=\"20\" gap=\"15\" active_section=\"1\" no_fill_content_area=\"true\" title=\"Itinerario\"][vc_tta_section title=\"TAPPA 1\" tab_id=\"1696344647582-eada1aca-2c350f92-61fd\"][vc_column_text]The first stop on our route concerns the town of <strong>Magliano Sabina<\/strong>, easy to reach from the A1 highway, exit Magliano. The town of Magliano in ancient times belonged to the Roman municipium of Ocriculum.\r\n\r\nFrom 1311 it became a free commune, and in 1495, just near the end of the Middle Ages, at the behest of Pope Alexander Borgia, it became the seat of the Diocese of Sabina.\r\n\r\nLike other towns that have developed on the banks of the Tiber, Magliano has relied on the possibilities that the river over the centuries has granted. And as a first port of call, surely the <strong>Archaeological Civic Museum<\/strong> offers great points of interest and curiosity. Built by the Lazio Region in 1989, it is housed in the historic home of <strong>Palazzo Gori<\/strong>. In the museum great space is given to artifacts dating from the Middle and Upper Paleolithic, sections devoted to Protohistory and the Archaic period. The Hellenistic, Roman and medieval phases on the second floor of the museum. The village is architecturally classic and the views beautiful.[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Indicazioni stradali punto di partenza tappa 1\" style=\"outline\" shape=\"square\" color=\"green\" i_align=\"right\" i_icon_fontawesome=\"fas fa-route\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2F02046%2BMagliano%2BSabina%2BRI%2F%4042.3659807%2C12.4645762%2C15z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132f19ad59225c53%3A0xda3972f1f8315b57!8m2!3d42.364143!4d12.4788065!16zL20vMGdtNWwx%3Fentry%3Dttu|target:_blank\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Vai alla scheda del comune di Magliano\" style=\"outline\" shape=\"square\" color=\"warning\" i_align=\"right\" i_icon_fontawesome=\"far fa-file-alt\" add_icon=\"true\" link=\"url:https%3A%2F%2Fgeosabina.it%2Fdestinations%2Fmagliano-sabina%2F\"][\/vc_column_inner][\/vc_row_inner][\/vc_tta_section][vc_tta_section title=\"TAPPA 2\" tab_id=\"1696344647611-95d2120a-89620f92-61fd\"][vc_column_text]Leaving the village, taking provincial road 54, in the direction of the northwest viaduct Santa Maria, we move to the village of Tarano, about 18 km from Magliano. <strong>Tarano<\/strong> is a cosy, typically medieval village on the rolling hills of Sabina, with old stone houses and the unmistakable structure of ancient settlements. A pre-Romanesque cathedral provides space for the beautiful 12th-century bell tower. A welcoming village of typical traditions, it can be an ideal place to refresh oneself and admire the surrounding beauty.[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Indicazioni stradali punto di partenza tappa 2\" style=\"outline\" shape=\"square\" color=\"green\" i_align=\"right\" i_icon_fontawesome=\"fas fa-route\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2F02040%2BTarano%2BRI%2F%4042.3561363%2C12.5929325%2C17z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132f1ae6e399e251%3A0x73fd48edd89a9a20!8m2!3d42.3577773!4d12.5968303!16zL20vMGdtNmc3%3Fentry%3Dttu|target:_blank\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Vai alla scheda del comune di Tarano\" style=\"outline\" shape=\"square\" color=\"warning\" i_align=\"right\" i_icon_fontawesome=\"far fa-file-alt\" add_icon=\"true\" link=\"url:https%3A%2F%2Fgeosabina.it%2Fdestinations%2Ftarano%2F\"][\/vc_column_inner][\/vc_row_inner][\/vc_tta_section][vc_tta_section title=\"TAPPA 3\" tab_id=\"1696344891500-aa2c7edd-9eb60f92-61fd\"][vc_column_text]From Tarano, it is a ten-minute drive to the impressive <strong>Sanctuary of Vescovio<\/strong>. Undoubtedly, the Sanctuary is the oldest center of both the civil and religious history of the Sabine territory. An ancient Roman city, Forum Novum, with the advent of Christianity, it became the focus of faith. The Sanctuary was founded in the fourth century AD and was the seat of the Sabine bishops until 1495. A beautiful park surrounds the Sanctuary, a destination in spring and summer for privileged walks.[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Indicazioni stradali punto di partenza tappa 3\" style=\"outline\" shape=\"square\" color=\"green\" i_align=\"right\" i_icon_fontawesome=\"fas fa-route\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2FSantuario%2BVescovio%2F%4042.3297689%2C12.6021421%2C17z%2Fdata%3D!4m15!1m8!3m7!1s0x132f1aa4797ab3cb%3A0x44359fcb21bcf718!2sStr.%2BSantuario%2BVescovio%2C%2B68%2C%2B02049%2BTorri%2Bin%2BSabina%2BRI!3b1!8m2!3d42.329765!4d12.604717!16s%252Fg%252F11c5f8_k20!3m5!1s0x132f0521324b0f6f%3A0xa28c68d4ccb3b8f6!8m2!3d42.3311634!4d12.6048341!16s%252Fg%252F1yp37ly3j%3Fentry%3Dttu|target:_blank\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Vai alla scheda del Santuario di Vescovio\" style=\"outline\" shape=\"square\" color=\"warning\" i_align=\"right\" i_icon_fontawesome=\"far fa-file-alt\" add_icon=\"true\" link=\"url:https%3A%2F%2Fgeosabina.it%2Faltri-comuni%2Fvescovio-area-archeologica-forum-novum-e-santuario%2F\"][\/vc_column_inner][\/vc_row_inner][\/vc_tta_section][\/vc_tta_tour][vc_row_inner el_class=\"video_app\"][vc_column_inner offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"4\" slider_loop=\"yes\" slider_autoplay=\"yes\" slider_navigation=\"yes\" slider_pagination=\"yes\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"25px\"][vc_empty_space height=\"25px\"][vc_column_text]\r\n<h2><strong>Video<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"25px\"][vc_empty_space height=\"25px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][\/vc_column][\/vc_row]","post_title":"Magliano Sabina, Tarano e Vescovio","post_link":"https:\/\/geosabina.it\/en\/routes\/magliano-sabina-tarano-e-vescovio\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Magliano Sabina, Tarano e Vescovio\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/10\/itinerari-artistici-300x191.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_thumbnail_id%":"9144","%_edit_lock%":"1696496472:6","%_wpb_shortcodes_custom_css%":".vc_custom_1696496103532{margin-top: -20px !important;}.vc_custom_1696326100559{border-top-width: 10px !important;border-right-width: 10px !important;border-bottom-width: 10px !important;border-left-width: 10px !important;padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;background-color: #f4f4f4 !important;border-left-color: #ffffff !important;border-left-style: solid !important;border-right-color: #ffffff !important;border-right-style: solid !important;border-top-color: #ffffff !important;border-top-style: solid !important;border-bottom-color: #ffffff !important;border-bottom-style: solid !important;}.vc_custom_1696325961236{padding: 20px !important;}.vc_custom_1696326193021{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696326261455{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696326280823{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696326295906{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696349541619{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":363,\"to_translate\":{\"en\":363}}","%_wpml_location_migration_done%":"1","%_wpgmp_location_address%":"02046 Magliano Sabina RI, Italia","%_wpgmp_location_city%":"Magliano Sabina","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.364143","%_wpgmp_metabox_longitude%":"12.4788065","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"3\";i:1;s:2:\"16\";i:2;s:2:\"17\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"22\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_wpb_post_custom_css%":".itinerari {\r\n    width:100%;\r\n    max-width:300px;\r\n}","%_dp_original%":"6846","%_edit_last%":"6","%_last_translation_edit_mode%":"native-editor","%_yoast_wpseo_focuskw%":"Magliano Sabina, Tarano e Vescovio","%_yoast_wpseo_metadesc%":"This itinerary can take 1 or even 2 days with an overnight stay, depending very much on the time one has available. The itinerary is very varied and offers the possibility to visit 2 villages, of the Lower Sabina, of great artistic interest as well as the beautiful Sanctuary of Vescovio.","%_yoast_wpseo_linkdex%":"62","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_wp_attachment_metadata%":"","taxonomy=translation_priority":"Optional, Optional"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari-artistici_sito.png"},"id":6909,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari-artistici_sito.png","name":"Itinerari Artistici \/ Artistic Itineraries","id":"22","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Tevere Farfa Oasis","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Tevere Farfa Oasis\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/07\/itinerari-logo-300x191.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/en\/routes\/tevere-farfa-oasis\/\" class=\"fc-post-link\">Tevere Farfa Oasis<\/a><\/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":"02047 Poggio Mirteto Scalo RI, Italia","location":{"lat":"42.2461204","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.6352566","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/en\/routes\/tevere-farfa-oasis\/","zoom":18,"extra_fields":{"post_excerpt":"","post_content":"[vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/4\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-sm vc_hidden-xs\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_single_image image=\"9145\" img_size=\"full\" alignment=\"center\" onclick=\"custom_link\" el_class=\"itinerari\" link=\"https:\/\/geosabina.it\/itinerari\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner el_class=\"info_app\" css=\".vc_custom_1696325961236{padding: 20px !important;}\"][vc_column_inner][vc_btn title=\"Download the Map\" style=\"flat\" shape=\"square\" color=\"green\" size=\"lg\" i_align=\"right\" i_icon_fontawesome=\"fas fa-angle-down\" add_icon=\"true\" link=\"url:https%3A%2F%2Fgeosabina.it%2Fwp-content%2Fuploads%2F2022%2F04%2Fcarta_dei_sentiere_riserva_tevere_farfa.pdf|target:_blank\"][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\"><strong>Tipologia<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696916197100{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Percorso a Piedi<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\"><strong>Numero Tappe<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696916039182{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">1<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\"><strong>Durata<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696916020443{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">About 3 hours<\/span><\/strong>.[\/vc_column_text][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\"><strong>Difficolt\u00e0<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696326295906{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Facile<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\"><strong>Punto di Partenza<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1696349541619{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Magliano Sabina<\/span><\/strong>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"3\/4\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Tevere Farfa <strong>Oasis<\/strong><\/h2>\r\n[\/vc_column_text][vc_column_text css=\".vc_custom_1696916250019{margin-top: -20px !important;}\"]\r\n<h5>Nature Itinerary<\/h5>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_column_text]The Tevere Farfa Oasis is a natural extension produced from the reservoir of the dam and the hydroelectric Enel Central. It stretches for several kilometers. The environment is lacustrine and swamp seeds with riparian vegetation and numerous species of birds. The natural oasis extends both along the right bank of the Tiber, including the towns of Nazzano and Torrita Tiberina, and on the left bank of the river, side of Poggio Mirteto Scalo. The route only encompasses the left side of the reserve, since on the right side the great highway bridge Rome-Florence dominates, and it is very noisy.\r\n\r\n<strong>Workload<\/strong>\r\n\r\nWalking: Km 6\r\n\r\nDifference in height: 35\r\n\r\n<strong>Equipment<\/strong>\r\n\r\nWe recommend a good pair of binoculars, a text for the recognition of plants and birds, sober colors clothing, comfortable shoes and suitable for muddy terrain, water and food (doggy bag).\r\n\r\n<strong>How to reach it<\/strong>\r\n\r\nBy car, from the Poggio Mirteto Scalo train station, walk 100 m. towards Rome up to a junction for Torrita Tiberina. You wiil reach, after a few meters, to a narrow metal bridge in alternating directions. Right after the bridge on the left starts a dirt road, with a sharp curve (recommended to walk a few meters ahead to a clearing where you can maneuver to go back and take the bend easily). The dirt road runs along the railway line on the left and on the right the Tiber. Walking for no more than 3 km you will come to a grassy area with the oasis sign. On the left a bar shows us not to continue with the car, on the right the dirt road continues. Here you can leave your car.\r\n\r\n<strong>Itinerary<\/strong>\r\n\r\nWatching the Tiber, continue to the left, south on the dirt road that continues slightly uphill. As soon as the road descended, take a path on the right, downhill, after no more than 50 meters you will be on the bank of the Tiber. The trail continues on the bank, shaded by various plant species, having on the right the Tiber and on the left a flat cultivated, where the way is getting wider. Travelling for about 3 km from the start, you come across a bridge. After passing the cable pulling the ferry. Continuing the way you will pass near the drainage basin that collects the waters of the plain, which until then we rode along and to get under the travertine cliffs of the promontory of the Well Field. At this point the path become very tight that widens in the vicinity of the railway sleepers. It takes a detour to the right and you get to a shed for wildlife observation. We are just at the confluence of the river Farfa with the river Tiber. Returning take the path, continuing around the promontory. When the trail goes up you get to the plateau above the Well Field, where the building of the guesthouse. Even from here, through reed walls, you can observe the fauna. The guest a dirt road runs around the headland, leading to a set of paths, near the old substation. You take a small road that runs along the right a fence and going downhill. The trail leads to a narrow valley and after about one km you arrive at the starting point and where we left the car.\r\n\r\n<strong>What to See<\/strong>\r\n\r\nThe most common plant species are willows and poplars. In particular, the white willow with narrow and elongated leaves. The poplars can be easily recognized by their large leaves, ovate and ovate-webbed. There are also walnut trees.\r\n\r\nAmong the shrubs are very common viburnum and ligustrello. The banks are covered by the common reed and iris marsh. It \u2018easy to meet also dense groupings of horsetail.\r\n\r\nThe basin is home to numerous species of birds, the gray heron, the teal, wigeon, mallard, pintail and the tufted folana, aquatic birds that can be easily observed. The fish in the basin are barbel, tench, chub perch and carp.\r\n\r\nThe route is a pleasant walk, and can be practiced throughout the year. Of course, during rainy periods it is not recommended for the muddiness of the land. In spring and summer it is very suitable and autumn offers the typical warm colors of the local vegetation.[\/vc_column_text][vc_empty_space height=\"20px\"][vc_row_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Indicazioni stradali punto di partenza tappa 1\" style=\"outline\" shape=\"square\" color=\"green\" i_align=\"right\" i_icon_fontawesome=\"fas fa-route\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.com%2Fmaps%2F%4042.2347785%2C12.6292277%2C3a%2C75y%2C190.19h%2C76.49t%2Fdata%3D!3m6!1e1!3m4!1stPJ6q26FCJA77uQblOD-yw!2e0!7i16384!8i8192%3Fhl%3Dit%26entry%3Dttu|target:_blank\"][\/vc_column_inner][vc_column_inner width=\"1\/2\" offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_btn title=\"Vai alla scheda del comune di Magliano\" style=\"outline\" shape=\"square\" color=\"warning\" i_align=\"right\" i_icon_fontawesome=\"far fa-file-alt\" add_icon=\"true\" link=\"url:https%3A%2F%2Fgeosabina.it%2Fdestinations%2Fmagliano-sabina%2F\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner el_class=\"video_app\"][vc_column_inner offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"4\" slider_loop=\"yes\" slider_autoplay=\"yes\" slider_navigation=\"yes\" slider_pagination=\"yes\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"25px\"][vc_empty_space height=\"25px\"][vc_column_text]\r\n<h2><strong>Video<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"25px\"][vc_video link=\"https:\/\/youtu.be\/vF4cAi5cPrU\"][vc_empty_space height=\"25px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Tevere Farfa Oasis","post_link":"https:\/\/geosabina.it\/en\/routes\/tevere-farfa-oasis\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Tevere Farfa Oasis\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/07\/itinerari-logo-300x191.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpb_shortcodes_custom_css%":".vc_custom_1696325961236{padding: 20px !important;}.vc_custom_1696916197100{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696916039182{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696916020443{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696326295906{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696349541619{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696916250019{margin-top: -20px !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":716,\"to_translate\":{\"en\":716}}","%_wpml_location_migration_done%":"1","%_wpgmp_location_address%":"02047 Poggio Mirteto Scalo RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2461204","%_wpgmp_metabox_longitude%":"12.6352566","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"3\";i:1;s:2:\"16\";i:2;s:2:\"17\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"19\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_dp_original%":"6826","%_wpb_post_custom_css%":".itinerari {\r\n    width:100%;\r\n    max-width:300px;\r\n}","%_thumbnail_id%":"6921","%_edit_lock%":"1696916509:6","%_edit_last%":"6","%_last_translation_edit_mode%":"native-editor","%_yoast_wpseo_focuskw%":"Tevere Farfa Oasis","%_yoast_wpseo_metadesc%":"The Tevere Farfa Oasis is a natural extension produced from the reservoir of the dam and the hydroelectric Enel Central. It stretches for several kilometers.","%_yoast_wpseo_linkdex%":"65","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_wordproof_timestamp%":"","%_wp_attachment_metadata%":"","taxonomy=translation_priority":"Optional"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari_sito.png"},"id":6905,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari_sito.png","name":"Itinerari Naturalistici \/ Nature Trails","id":"19","type":"category","extension_fields":{"cat_order":"1"}}]}],"map_property":{"map_id":"17","debug_mode":true},"shapes":{"drawing_editable":false},"filters":{"filters_container":"[data-container=\"wpgmp-filters-container\"]"},"marker_category_icons":{"1":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/bellezze-naturali_sito.png","2":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png","3":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/biblioteche_sito.png","4":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png","5":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dimore-storiche_sito.png","6":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dove-dormire_sito.png","7":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dove-mangiare_sito.png","8":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/monumenti_sito.png","9":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/musei_sito.png","10":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/produzione-tipica_sito.png","11":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-panoramico_sito.png","12":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/servizi-di-persone_sito.png","13":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/archeologia_sito.png","14":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/teatri_sito.png","15":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/stazione_sito.png","16":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/curiosita_sito.png","17":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-generico_sito.png","18":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info_sito.png","19":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari_sito.png","20":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/piazze-digitali_sito.png","21":"https:\/\/geosabina.it\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png","22":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari-artistici_sito.png","23":"https:\/\/geosabina.it\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/pin_green.png"}}