{"map_options":{"center_lat":"43.0278564","center_lng":"11.6180724","zoom":4,"map_type_id":"TERRAIN","fit_bounds":false,"draggable":true,"scroll_wheel":true,"display_45_imagery":"","marker_default_icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","infowindow_setting":"<div class=\"fc-item-box fc-item-no-padding\">\n    {marker_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\">{marker_category}<\/div>\n<div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">{marker_title}<\/div>\n<div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\n                {marker_message}\n            <\/div>\n<\/p><\/div>\n<\/p><\/div>\n<\/div>\n","infowindow_bounce_animation":"","infowindow_drop_animation":false,"close_infowindow_on_map_click":false,"infowindow_skin":{"name":"udine","type":"infowindow","sourcecode":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    {marker_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\">{marker_category}<\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">{marker_title}<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                {marker_message}\r\n            <\/div>\r\n\r\n        <\/div>\r\n    <\/div>\r\n<\/div>"},"default_infowindow_open":false,"infowindow_open_event":"click","full_screen_control":true,"search_control":true,"zoom_control":true,"map_type_control":true,"street_view_control":true,"full_screen_control_position":"TOP_LEFT","search_control_position":"TOP_LEFT","zoom_control_position":"TOP_LEFT","map_type_control_position":"TOP_LEFT","map_type_control_style":"HORIZONTAL_BAR","street_view_control_position":"TOP_LEFT","map_control":true,"map_control_settings":false,"map_zoom_after_search":6,"width":"","height":"600"},"places":[{"id":"1","title":"Locanda del Loggiato","address":"Piazza del Moretto, 3053027 Bagno VignoniSan Quirico d'Orcia - Siena, SR2, San Quirico d'Orcia, Province of Siena, Italy","source":"manual","content":"<h2>Locande del Loggiato<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.com\/wp-content\/uploads\/2020\/10\/locanda-del-loggiato-bagno-vignoni-toscana.jpg\"><\/img>\r\n<br\/><em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2020\/10\/07\/locanda-del-loggiato-bed-and-breakfast-bagno-vignoni-toscana\/\">Read the article ><\/a><\/em>","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"43.0278564","lng":"11.6180724","city":"San Quirico D'orcia","state":"Toscana","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"2","title":"Villa Pienza","address":"Villa Pienza, Pienza, Province of Siena, Italy","source":"manual","content":"<h2>Villa Pienza<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.com\/wp-content\/uploads\/2020\/10\/villa-tuscany-holiday-home-pienza.jpg\"><\/img><br\/>\r\n<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2020\/09\/13\/villa-pienza-casa-vacanze-toscana\/\">Read the article ><\/a><\/em>","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"43.0586779","lng":"11.6764805","city":"Pienza","state":"Toscana","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"3","title":"Maso di Villa Relais di campagna e Cantina","address":"Via Col di Guarda, 15, 31058 Susegana, TV, Italy","source":"manual","content":"<h2>Maso di Villa<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.com\/wp-content\/uploads\/2020\/10\/maso-di-villa-relais-di-campagna-susegana-veneto.jpg\"><\/img>\r\n<br\/><em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2020\/09\/23\/maso-di-villa-relais-di-campagna-e-cantina-susegana\/\">Read the article ><\/a><\/em>","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"45.87280029999999","lng":"12.2083962","city":"Susegana","state":"Veneto","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"4","title":"Apricus Locanda","address":"Apricus Locanda, Via IV Novembre, Apricale, Province of Imperia, Italy","source":"manual","content":"<h2>Apricus Locanda<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.com\/wp-content\/uploads\/2020\/10\/apricus-locanda-bed-and-breakfast-apricale.jpg\"><\/img><br\/>\r\n<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2020\/08\/04\/apricus-locanda-apricale-bed-and-breakfast-liguria\/\">Read the article ><\/a><\/em>","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"43.8793367","lng":"7.6584698","city":"Apricale","state":"Liguria","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"5","title":"Follonico","address":"Follonico, Localit\u00e0 Casale, Torrita di Siena, Province of Siena, Italy","source":"manual","content":"<h2>Follonico<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.com\/wp-content\/uploads\/2020\/10\/follonico-bed-and-breakfast-charme-campagna-toscana.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2020\/08\/14\/follonico-torrita-di-siena-agriturismo-toscana\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"43.13318330000001","lng":"11.7673361","city":"Torrita di Siena","state":"Toscana","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"6","title":"Look To","address":"LOOK TO - Piazza Vittorio 8, Piazza Vittorio Veneto, Torino, Metropolitan City of Turin, Italy","source":"manual","content":"<h2>Look To<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.files.wordpress.com\/2020\/10\/look-to-bed-and-breakfast-charme-torino.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2020\/08\/26\/look-to-bed-and-breakfast-charme-torino\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"45.0654212","lng":"7.693515400000001","city":"Torino","state":"Piemonte","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"7","title":"La Fustaia","address":"La Fustaia, Via dei Molini, Sarzana, SP, Italy","source":"manual","content":"<h2>La Fustaia<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.com\/wp-content\/uploads\/2020\/07\/la-fustaia-sarzana-bed-and-breakfast-charme.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2020\/07\/17\/la-fustaia-sarzana-liguria\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"44.1258337","lng":"9.9735012","city":"Sarzana","state":"Liguria","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"8","title":"Ch\u00e2teau de Dirac","address":"Ch\u00e2teau de Dirac, Le Ch\u00e2teau, Dirac, France","source":"manual","content":"<h2>Ch\u00e2teau de Dirac<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.com\/wp-content\/uploads\/2020\/10\/hateau-de-dirac-cottage-for-rent.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2020\/04\/21\/chateau-de-dirac\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"45.6058136","lng":"0.2516337000000001","city":"Dirac","state":"Nouvelle-Aquitaine","country":"France","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"9","title":"Ca\u2019 Alfieri al 30","address":"Ca` Alfieri al trenta, Corso Alfieri di Sostegno, Govone, Province of Cuneo, Italy","source":"manual","content":"<h2>Ca\u2019 Alfieri al 30<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.files.wordpress.com\/2020\/02\/ca-alfieri-al-30-guesthouse-roero.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2020\/02\/24\/ca-alfieri-al-30-bed-and-breakfast-piscina-roero\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"44.804549","lng":"8.097273999999999","city":"Govone","state":"Piemonte","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"10","title":"Le Moulin Bregeon","address":"Le Moulin Bregeon, Lini\u00e8res-Bouton, France","source":"manual","content":"<h2>Le Moulin Bregeon<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.com\/wp-content\/uploads\/2020\/10\/le-moulin-bregeon-chambre-d-hotes-vintage-france.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2020\/02\/06\/le-moulin-bregeon-bed-and-breakfast-charme-valle-della-loira\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"47.45383640000001","lng":"0.06727780000000001","city":"Lini\u00e8res-Bouton","state":"Pays de la Loire","country":"France","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"11","title":"Bellevue Hotel","address":"Bellevue Hotel & Spa, Rue Grand Paradis, Cogne, Aosta Valley, Italy","source":"manual","content":"<h2>Bellevue Hotel<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.files.wordpress.com\/2020\/01\/hotel-bellevue-cogne-spa.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2020\/01\/14\/camera-con-vista-sul-gran-paradiso-il-bellevue-hotel-di-cogne\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"45.6066815","lng":"7.355520800000003","city":"Cogne","state":"Valle d'Aosta","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"12","title":"Locanda Rosa Rosae","address":"Locanda Rosa Rosae, Via Molino, Breda di Piave, Province of Treviso, Italy","source":"manual","content":"<h2>Locanda Rosa Rosae<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.files.wordpress.com\/2019\/12\/locanda-rosa-rosae-bed-and-breakfast-charme-treviso-1.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2019\/12\/05\/locanda-rosa-rosae\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"45.70682139999999","lng":"12.3985901","city":"San Biagio di Callalta","state":"Veneto","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"13","title":"Villa 61","address":"B&B Villa 61 - Maison de Campagne - Limana , Belluno, Via Villa, Limana, Province of Belluno, Italy","source":"manual","content":"<h2>Villa 61<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.files.wordpress.com\/2019\/09\/villa-61-ely-garage-28.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2019\/09\/21\/villa-61-maison-de-campagne\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"46.092775","lng":"12.174266","city":"Limana","state":"Veneto","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"14","title":"L\u2019Esprit des Lieux","address":"L'Esprit des Lieux - Chambres d'h\u00f4tes, Rue de la Vieille Cure, Lu\u00e7on, France","source":"manual","content":"<h2>L\u2019Esprit des Lieux<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.files.wordpress.com\/2019\/11\/l-esprit-des-lieux-france-1.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2019\/11\/08\/lesprit-des-lieux\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"46.4558434","lng":"-1.1683363","city":"Lu\u00e7on","state":"Pays de la Loire","country":"France","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"15","title":"L\u2019\u00c9picerie de V\u00e9nat","address":"L' \u00e9picerie de V\u00e9nat Chambres d'h\u00f4tes Angoul\u00eame Charente, Rue Jean Ravanaud, Saint-Yrieix-sur-Charente, France","source":"manual","content":"<h2>L\u2019\u00c9picerie de V\u00e9nat<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.files.wordpress.com\/2019\/10\/l-epicerie-de-venat-chambre-d-hotes-chambre-angouleme.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2019\/10\/15\/lepicerie-de-venat\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"45.689377","lng":"0.113875","city":"Saint-Yrieix-sur-Charente","state":"Nouvelle-Aquitaine","country":"France","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"16","title":"Casa Tal\u00eca","address":"Casa Tal\u00eda slowliving, Via Exaudinos, Modica, Free municipal consortium of Ragusa, Italy","source":"manual","content":"<h2>Casa Tal\u00eca<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.files.wordpress.com\/2019\/08\/casa-talia-modica-boutique-hotel.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2019\/08\/07\/casa-talia\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"36.8616409","lng":"14.7586269","city":"Modica","state":"Sicilia","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"17","title":"Maison Empereur","address":"Maison Empereur, Rue des R\u00e9colettes, Marseille, France","source":"manual","content":"<h2>Maison Empereur<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.com\/wp-content\/uploads\/2020\/10\/guesthouse-vintage-style-marseille.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2019\/06\/28\/maison-empereur\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"43.2961428","lng":"5.378625899999999","city":"Marseille","state":"Provence-Alpes-C\u00f4te d'Azur","country":"France","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"18","title":"La Belle Vue","address":"La Belle Vue, Avenue de Fontes, Neffi\u00e8s, France","source":"manual","content":"<h2>La Belle Vue<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.com\/wp-content\/uploads\/2020\/10\/la-belle-vue-bed-and-breakfast-france.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2019\/05\/25\/la-belle-vue\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"43.5334708","lng":"3.3333133","city":"Neffi\u00e8s","state":"Occitanie","country":"France","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"19","title":"Camellas-Lloret","address":"camellas-lloret maison d'h\u00f4tes, Rue de l'Angle, Montr\u00e9al, France","source":"manual","content":"<h2>Camellas-Lloret<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.files.wordpress.com\/2019\/06\/camellas-lloret-france-1.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2019\/06\/05\/camellas-lloret\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"43.1992523","lng":"2.1413724","city":"Montr\u00e9al","state":"Occitanie","country":"France","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"20","title":"Ch\u00e2teau d\u2019Uzer","address":"Ch\u00e2teau d'Uzer : maison d'H\u00f4tes, d'amis, de famille, place G\u00e9n\u00e9ral Mangin, Uzer, France","source":"manual","content":"<h2>Ch\u00e2teau d\u2019Uzer<\/h2>\r\n<img src=\"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2019\/05\/2_chateau-d-uzer-chambre-d-hotes-chambre-general.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2019\/05\/11\/chateau-duzer\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"44.5188433","lng":"4.326328599999999","city":"Uzer","state":"Auvergne-Rh\u00f4ne-Alpes","country":"France","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"21","title":"Maison Parco del Brenta","address":"B&B Maison Parco del Brenta Curtarolo, di Curtarolo, Via Monte Pasubio, Pieve, Province of Padua, Italy","source":"manual","content":"<h2>Maison Parco del Brenta<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.com\/wp-content\/uploads\/2020\/10\/maison-parco-del-brenta.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2019\/04\/14\/bb-maison-parco-del-brenta\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"45.5340673","lng":"11.8174182","city":"Curtarolo","state":"Veneto","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"22","title":"Ca\u2019 Bevilacqua","address":"Ca' Bevilacqua B&B, Via Santa Croce, Bertinoro, Province of Forl\u00ec-Cesena, Italy","source":"manual","content":"<h2>Ca\u2019 Bevilacqua<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.com\/wp-content\/uploads\/2018\/12\/ca-bevilacqua-romagna-breakfast-room.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2018\/12\/12\/ca-bevilacqua\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"44.2135511","lng":"12.1995264","city":"Bertinoro","state":"Emilia-Romagna","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"23","title":"Le Molina","address":"Le Molina B&B, Via Gamberaiolo, Massa e Cozzile, Province of Pistoia, Italy","source":"manual","content":"<h2>Le Molina<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.com\/wp-content\/uploads\/2019\/02\/bb-le-molina-bed-and-breakfast-tarte.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2019\/02\/11\/le-molina-bb\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"43.9037702","lng":"10.7528428","city":"Massa e Cozzile","state":"Toscana","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"24","title":"Valdirose","address":"Valdirose, Via Valdirose, Lastra a Signa, Metropolitan City of Florence, Italy","source":"manual","content":"<h2>Valdirose<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.com\/wp-content\/uploads\/2020\/10\/valdirose-charming-room-florence-vintage-bed-and-breakfast.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2020\/10\/30\/valdirose-lastra-a-signa\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"43.7660702","lng":"11.0982155","city":"Lastra a Signa","state":"Toscana","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"25","title":"Numeroventi","address":"Numeroventi Design Residency, Via dei Pandolfini, Florence, Metropolitan City of Florence, Italy","source":"manual","content":"<h2>Numeroventi<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.com\/wp-content\/uploads\/2020\/11\/numeroventi-studio-appartamento-firenze.jpg\"><\/img><br\/>\r\n<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2020\/11\/14\/numeroventi-firenze\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"43.77093780000001","lng":"11.2595512","city":"Firenze","state":"Toscana","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"26","title":"Le convertite","address":"Leconvertite, Via San Girolamo, Treviso, Province of Treviso, Italy","source":"manual","content":"<h2>Le Convertite<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.com\/wp-content\/uploads\/2020\/11\/chambre-d-hotes-charme-italie-le-convertite-veneto-1.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2020\/11\/29\/le-convertite-treviso\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"45.6668675","lng":"12.2526216","city":"Treviso","state":"Veneto","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"27","title":"Oltrarno Splendid","address":"Oltrarno Splendid, Via dei Serragli, Florence, Metropolitan City of Florence, Italy","source":"manual","content":"<h2>Oltrarno Splendid<\/h2>\r\n<img src=\"https:\/\/tweetandtravel.com\/wp-content\/uploads\/2021\/01\/oltrarno-splendid-suite-and-breakfast-florence.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/tweetandtravel.com\/2021\/01\/26\/oltrarno-splendid\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"43.76851409999999","lng":"11.2463881","city":"Firenze","state":"Toscana","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"28","title":"La Scuola","address":"B&B La Scuola Guesthouse, Via Campana, Campana, Province of Vicenza, Italy","source":"manual","content":"<h2>La Scuola<\/h2>\r\n<img src=\"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2021\/04\/la-scuola-lusiana-guesthouse-bed-and-breakfast.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/slowlivinghideaway.com\/2021\/04\/20\/la-scuola-guesthouse-lusiana-veneto\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"45.789603","lng":"11.5533142","city":"Lusiana","state":"Veneto","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"29","title":"Hotel Flora","address":"Hotel Flora, San Marco, Venezia, Metropolitan City of Venice, Italy","source":"manual","content":"<h2>Hotel Flora<\/h2>\r\n<img src=\"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2021\/05\/1_hotel-flora-san-marco-venezia.jpg\"><\/img><br\/>\r\n\r\n\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"45.4323954","lng":"12.3344263","city":"Venezia","state":"Veneto","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"30","title":"Casa Flora","address":"Casa Flora Venezia, San Marco, Venice, Metropolitan City of Venice, Italy","source":"manual","content":"<h2>Casa Flora<\/h2>\r\n<img src=\"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2021\/05\/1_casa-flora-venezia.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/slowlivinghideaway.com\/2021\/05\/06\/casa-flora-venezia\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"45.4326148","lng":"12.334118","city":"Venezia","state":"Veneto","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"31","title":"Novecento","address":"Novecento Boutique Hotel, San Marco, Venice, Metropolitan City of Venice, Italy","source":"manual","content":"<h2>Novecento<\/h2>\r\n<img src=\"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2021\/05\/novecento-boutique-hotel-venice-breakfast-1.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/slowlivinghideaway.com\/2021\/05\/25\/novecento-boutique-hotel-venezia\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"45.43238169999999","lng":"12.3312206","city":"Venezia","state":"Veneto","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"32","title":"Glamping Canonici di San Marco","address":"Glamping Canonici di San Marco, Via Accopp\u00e8 Fratte, Mirano, Metropolitan City of Venice, Italy","source":"manual","content":"<h2>Glamping Canonici di San Marco<\/h2>\r\n<img src=\"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2021\/06\/glamping-italy-venezia-canonici-di-san-marco-1.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/slowlivinghideaway.com\/2021\/06\/05\/glamping-canonici-di-san-marco-veneto\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"45.4895888","lng":"12.0615289","city":"Mirano","state":"Veneto","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"33","title":"L'Immacolata","address":"L'IMMACOLATA, Via Immacolata, Matino, Province of Lecce, Italy","source":"manual","content":"<h2>L'Immacolata<\/h2>\r\n<img src=\"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2021\/06\/casa-vacanze-puglia-salento-l-immacolata-matino.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/slowlivinghideaway.com\/2021\/06\/18\/limmacolata-matino\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"40.0336687","lng":"18.1342384","city":"Matino","state":"Puglia","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"34","title":"Palazzo Daniele","address":"Palazzo Daniele, Corso Umberto I, Gagliano del Capo, Province of Lecce, Italy","source":"manual","content":"<h2>Palazzo Daniele<\/h2>\r\n<img src=\"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2021\/07\/palazzo-daniele-dimora-aristocratica-hotel-gagliano-del-capo-1.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/slowlivinghideaway.com\/2021\/07\/08\/palazzo-daniele-hotel-lusso-gagliano-del-capo-puglia\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"39.8441848","lng":"18.3729896","city":"Gagliano del capo","state":"Puglia","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"35","title":"Riad Salentino","address":"IL RIAD SALENTINO, Via Immacolata, Matino, Province of Lecce, Italy","source":"manual","content":"<h2>Riad Salentino<\/h2>\r\n<img src=\"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2021\/07\/acqua-di-puglia-casa-vacanze-salento-riad-salentino-matino.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/slowlivinghideaway.com\/?p=6856&preview=true&_thumbnail_id=6866\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"40.033938","lng":"18.134062","city":"Matino","state":"Puglia","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"36","title":"Trullo Nostrano","address":"Termetrio, Cisternino, BR, Italy","source":"manual","content":"<h2>Trullo Nostrano<\/h2>\r\n<img src=\"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2021\/08\/trullo-nostrano-cisternino-1.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/slowlivinghideaway.com\/2021\/08\/10\/trullo-nostrano-cisternino-casa-vacanze\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"40.7478381","lng":"17.4586283","city":"Cisternino","state":"Apulia","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"37","title":"La Guardia","address":"Via Thaon de Revel, 45, Giglio Porto, Province of Grosseto, Italy","source":"manual","content":"<h2>La Guardia<\/h2>\r\n<img src=\"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2021\/08\/la-guardia-hotel-giglio-island-tuscany.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/slowlivinghideaway.com\/2021\/08\/25\/la-guardia-hotel-isola-del-giglio-toscana\/\">Read the article ><\/a><\/em>","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"42.360233","lng":"10.9195281","city":"Isola del Giglio","state":"Toscana","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"38","title":"The Lazy Olive Glamping","address":"The Lazy Olive Glamping, Strada Vicinale della Rosa, Petroio, Province of Siena, Italy","source":"manual","content":"<h2>The Lazy Olive Glamping<\/h2>\r\n<img src=\"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2021\/08\/the-lazy-olive-glamping-dormire-in-tenda-toscana.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/slowlivinghideaway.com\/2021\/09\/06\/the-lazy-olive-glamping-toscana-italia\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"43.13863889999999","lng":"11.6971811","city":"Trequanda","state":"Toscana","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"39","title":"Masseria Moroseta","address":"Masseria Moroseta, Contrada Lamacavallo, Ostuni, BR, Italy","source":"manual","content":"<h2>Masseria Moroseta<\/h2>\r\n<img src=\"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2021\/09\/masseria-moroseta-ostuni.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/slowlivinghideaway.com\/2021\/09\/19\/masseria-moroseta-ostuni-puglia-agriturismo-moderno\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"40.73467","lng":"17.611805","city":"Ostuni","state":"Puglia","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"40","title":"Le Grotte della Civita","address":"Sextantio le Grotte della Civita, Via Civita, Matera, Province of Matera, Italy","source":"manual","content":"<h2>Le Grotte della Civita Sexantio<\/h2>\r\n<img src=\"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2021\/10\/grotte-della-civita-matera.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/slowlivinghideaway.com\/2021\/10\/03\/le-grotte-della-civita-matera-albergo-diffuso\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"40.6676361","lng":"16.61185039999999","city":"Matera","state":"Basilicata","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"41","title":"The Landscape Lodge","address":"The Landscape Lodge, Chemin du Clos des Abeilles, Abondance, France","source":"manual","content":"<h2>The Landscape Lodge<\/h2>\r\n<img src=\"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2022\/02\/TheLandscapeLodge_AntonellaMachet-61.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/slowlivinghideaway.com\/2022\/02\/14\/the-landscape-lodge-chalet-alpi-francesi\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"46.28953809999999","lng":"6.693703399999999","city":"Abondance","state":"Auvergne-Rh\u00f4ne-Alpes","country":"France","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"42","title":"Hotel Le S\u00e9n\u00e9chal","address":"H\u00f4tel Le S\u00e9n\u00e9chal, Rue Gambetta, Ars-en-R\u00e9, France","source":"manual","content":"<h2>Hotel Le S\u00e9n\u00e9chal<\/h2>\r\n<img src=\"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2020\/10\/hotel-ile-de-re-senechal-ars-en-re-1.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/slowlivinghideaway.com\/2020\/03\/21\/ile-de-re\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"46.2075","lng":"-1.5163889","city":"Ars-en-R\u00e9","state":"Nouvelle-Aquitaine","country":"France","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"43","title":"Les Ros\u00e9es","address":"Les Ros\u00e9es, Chemin de Font Neuve, Mougins, France","source":"manual","content":"<h2>Les Ros\u00e9es<\/h2>\r\n<img src=\"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2022\/06\/LesRosees_AntonellaMachet-24.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/slowlivinghideaway.com\/2023\/01\/09\/les-rosees-mougins-maison-d-hotes\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"43.6078521","lng":"6.9928523","city":"Mougins","state":"Provence-Alpes-C\u00f4te d'Azur","country":"France","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"44","title":"La Madone du Luberon","address":"66 Rue du Ballet, 84400 Apt, France","source":"manual","content":"<h2>La Madone du Luberon<\/h2>\r\n<img src=\"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2023\/06\/LaMadoneAPT_AntonellaMachet-6-1.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/slowlivinghideaway.com\/2023\/06\/22\/la-madone-apt\/\"> Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"43.8778402","lng":"5.3947067","city":"Apt","state":"Provence-Alpes-C\u00f4te d'Azur","country":"France","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"45","title":"La Divine Com\u00e9die","address":"La Divine Com\u00e9die, Impasse Jean Pierre Gras, Avignon, France","source":"manual","content":"<h2>La Divine Com\u00e9die<\/h2>\r\n<img src=\"https:\/\/slowlivinghideaway.com\/en\/wp-content\/uploads\/sites\/2\/2023\/10\/LaDivineComedie_AntonellaMachet1.jpg\"><\/img><br\/>\r\n<<em><a target=\"_blank\" href=\"https:\/\/slowlivinghideaway.com\/en\/2023\/10\/03\/la-divine-comedie-avignon-boutique-hotel\/\">Read the article ><\/a><\/em>\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"43.9508171","lng":"4.8106966","city":"Avignon","state":"Provence-Alpes-C\u00f4te d'Azur","country":"France","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""},{"id":"46","title":"Chalet 1864","address":"Chalet 1864, Route de Lormay, Le Grand-Bornand, France","source":"manual","content":"<h2>Chalet 1864<\/h2>\r\n<img src=\"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/02\/Chalet1864_Le-Grand-Bornand_AntonellaMachet-18.jpg\" \/><br \/>\r\n&lt;<em><a target=\"_blank\" href=\"https:\/\/slowlivinghideaway.com\/2024\/03\/01\/chalet-1864-le-grand-bornand-bed-and-breakfast\/\">Read the article &gt;<\/a><\/em>\r\n\r\n","location":{"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png","lat":"45.9490218","lng":"6.511959399999999","city":"Le Grand-Bornand","state":"Auvergne-Rh\u00f4ne-Alpes","country":"France","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"","name":"","type":"category","extension_fields":[],"icon":"https:\/\/slowlivinghideaway.com\/wp-content\/uploads\/2024\/04\/marker.png"}],"custom_filters":""}],"styles":"","listing":"","marker_cluster":"","map_property":{"map_id":"1","debug_mode":true}}