a:6:{i:0;s:18143:"				<div class="h1"><h1>Turkey & Greece Tours Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.shareoursource.in/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.shareoursource.in/tour-packages.htm" title="Tour Packages">Tour Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Turkey & Greece Tours Tour</p>
				<br />
				
								
						<script language="javascript"> 
							function topDestinationToggle(showHideDiv, switchTextDiv) {
							var ele = document.getElementById(showHideDiv);
							var text = document.getElementById(switchTextDiv);
							if(ele.style.display == "block") {
								ele.style.display = "none";
							  text.innerHTML = "View More &#9660;";
							}
							else {
							  ele.style.display = "block";
							  text.innerHTML = "View Less &#9650;";
							}
							}
		                </script>
											<script type="text/javascript">			
					(function($){	
					  $(function(){
						$('[id^=detailslider]').each(function(){
							$(this).DG_Slider({
								auto: true, mode:'fade', pager:true, pagerType:'short',controls:true
							});
						})
				
						$('a[rel=gall]').fancybox()
					  });	
					}(jQuery))
					</script>
					
					<br />
					<div class="data">
					<table class="w100 formTable bdr0 imgWidth">
					<tr>
					<td class="p10px">
					<table class="w100 packageForm">
											<tr>
						<td class="b p5px w125px vat">Tour Code </td>
						<td class="p5px pl0px vat">ISTOB01ATH</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Duration </td>
						<td class="p5px pl0px vat">
						9 Nights / 10 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Athens, Istanbul, Ephesus</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						USD 1306 Per Person						</td>
						</tr>
												<tr>
						<td class="b p5px dif w125px vat">Special Offer </td>
						<td class="p5px pl0px dif vat">Full payment at the time booking –Discount  INR 1000 per person<br />
Group Size more than 15 – Discount INR 2000 per person</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.shareoursource.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Turkey & Greece Tours Tour - Tour Package"/>
						<input type="hidden" name="allocate_type" value="tour"/>
						<a href="#" onclick="document.getElementById('frmpackagedetail').submit();" class="button p7px pl12px pr12px c5px b large dib mt10px">Book Your Tour</a>
						<input type="hidden" name="pkg_slno" value="63384"/>
						</form>
						</p>
						</td>
						</tr>
											</table>
					</td>
											<td class="p10px vat imgWidth150 w150px lh0">
						<div class="demo-wrap">
						<ul class="lsn m0px p0px" >
															<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w150px h150px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_15/433238/119007.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/433238/119007.jpg"  width="150" height="150"    alt="Turkey & Greece Tours Tour" title="Turkey & Greece Tours Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					SIGHTSEEING TOURS<br />
05 days Private touring in Turkey starting from in the morning of day 02 ending on afternoon of day 06  includes the following: Professional English speaking guide licensed by Ministry of Tourism<br />
Transport in A/C Tour coach ( 46 Seaters) Main entrance fees to sights visited, Lunch.<br />
Half day Athens sightseeing tour including Acropolis Museum & Entrance fees <br />
Full day Delphi tour with lunch  with  English Guide  including Entrance fees <br />
Full day cruise to Hydra Poros Aegina  with lunch ( private transfers ) <br />
Airport transfers in Istanbul on international arrival & departure<br />
All Transfers & Tours Private with Modern A/C Bus 50 seats in Greece<br />
<br />
TRANSPORTATION<br />
01 domestic flight : Istanbul to Kayseri  <br />
Oneway flight from Izmir to AthensFull payment at the time booking –Discount  INR 1000 per person<br />
Group Size more than 15 – Discount INR 2000 per personItems of a  personal nature<br />
Gratuities for Driver & Guide<br />
Meals not mentioned<br />
Drinks of any kind<br />						<div class="headHr">
			            <p class="p7px b pl10px xlarge">Tour Itinerary</p>
			            </div>
			            
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 1:</b> Istanbul
								</p>
								<p class="aj">Upon arrival in Istanbul (Ataturk Airport), our representative will meet you & transfer to the hotel.<br />
(Check-In after 13:00pm), where you will be briefed by your travel consultant. Overnight in Istanbul.</p>					
									<p><b>Meals : </b> Meals: Dinner</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 2:</b> Cappadocia
								</p>
								<p class="aj">Breakfast, visit to the ancient Byzantine Hippodrome where you will tour the Egyptian Obelisk, Serpentine Column, Fountain of Wilhelm II, the elegant Blue Mosque famous with its heavenly six minarets and the Hagia Sophia Museum, built during the reign of Emperor Theodosius and burned down in the fire of Nika Revolt in 532 A.D. Just before lunch break, you will visit the Caferaga Medresesi. After lunch break at local restaurant, you will visit the Topkapi Palace (excluding harem), residence and administrative center of the Ottoman Sultans. After tour Transfer to Ataturk airport for flight to Kayseri at 21:00pm<br />
22:20pm, Arrival to Nevsehir, transfer to hotel. Overnight in Cappadocia.</p>					
									<p><b>Meals : </b> Meals: Breakfast+Lunch+Dinner</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 3:</b> Cappadocia
								</p>
								<p class="aj">Breakfast,visit to the Pigeon Valley near Uchisar; then proceed to the Open Air Museum in Goreme through Avcilar Valley and visit to the early Christian churches decorated with unique frescoes depicting various scenes from the Bible then visit to Kaymakli Underground City. Pasabagi in Zelve region and Avanos with shopping facilities for the world-wide famous handicrafts, Back to hotel. Overnight in Cappadocia.</p>					
									<p><b>Meals : </b> Meals: Breakfast+Lunch+Dinner</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 4:</b> Pamukkale
								</p>
								<p class="aj">Early departure for Konya. On the way visit the 13 th century Seljukian caravanserai "Sultanhan". The next stop will be Konya Regarded by many as the oldest continuously inhabited city in Turkey, Konya has played an important religious role throughout history. Situated in the “Bread Basket of Turkey”, Konya is well known for its Whirling Dervishes, members of a religious order founded by Mevlana, a famous Sufi poet. Here you can visit the Mevlana Mausoleum and the Karatay Koran School with its colorful tiles. After tour depart for Pamukkale .Overnight in Pamukkale.</p>					
									<p><b>Meals : </b> Meals: Breakfast+Lunch+Dinner</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 5:</b> Pamukkale
								</p>
								<p class="aj">Breakfast Drive to Pamukkale, Discovery of Travertine terraces and Hierapolis. The travertine terraces at Pamukkale are one of the most spectacular natural wonders we ever have seen from various mineral springs in a vast white cliff side. Walk along the Hierapolis ancient city ruins, see the huge Necropolis, and feel the warmth of the natural spring as you go barefoot on the Travertens. Then If you like to swim in the Ancient Pool. Overnight in Kusadasi.</p>					
									<p><b>Meals : </b> Meals: Breakfast+Lunch+Dinner</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 6:</b> Ephesus & House of virgin
								</p>
								<p class="aj">Breakfast, depart on full day regular group Ephesus Sightseeing Tour (The Ancient City of Ephesus is known as one of the best preserved Greco-Roman cities. Here you have the chance to walk down marble streets, view the magnificent Celsius Library and the Grand Theatre, just a few of the many buildings and fountains that can be found in this open air museum. The day will also include visits to the House of Virgin Mary; where she is said to have spent the last of her days, and the remains of Artemis Temple which was one of the 7 Wonders of the Ancient World. Overnight in Kusadasi.</p>					
									<p><b>Meals : </b> Meals: Breakfast+Lunch+Dinner</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 7:</b> Athens
								</p>
								<p class="aj">03:00 am check-out from hotel and transfer to Izmir airport for morning flight to Athens at 06:10am.<br />
07:10 am, Arrival to Athens,:and meet for transfer on to the hotel and then meet to depart on a half day morning regular group tour to view some of the important sights of Athens such as Constitution Square (Syntagma), House of Parliament, Memorial to the Unknown Soldier, the National Library, Evzones in their picturesque uniform, the Presidential Palace and Hadrian’s Arch, Temple of Olympian Zeus and the Panathenaic Stadium where the first Olympic Games of the modern era were held in 1896. Then visit to the Acropolis (Propylaea, Temple of Athena Nike, Erechtheion and Parthenon) along with the New Acropolis Museum. After the tour the remainder of day at leisure. Overnight in Athens</p>					
									<p><b>Meals : </b> Meals: Breakfast</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 8:</b> Delphi Sightseeing
								</p>
								<p class="aj">Depart from Athens driving through the fertile plain of Boeotia, crossing the towns of Thebes connected with the tragedy of King Oedipus, Levadia & Arahova, famous for its colorful rugs and carpets. Arrive at Delphi the center of the Ancient world - the "Omphalos" (Navel) of the Earth - whose prestige extended far beyond the boundaries of the Hellenic world. On the slopes of Mt Parnassus, in a landscape of unparalleled beauty and majesty, lie the ruins of the Sanctuary of Apollo Pythios. Visit the Treasury of the Athenians, the Temple of Apollo and the Museum containing such masterpieces of ancient Greek sculpture as the bronze Charioteer and the famous athlete Aghias. Lunch in Delphi with return to Athens.</p>					
									<p><b>Meals : </b> Meals: Breakfast+Lunch</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 9:</b> Saronic Island Cruise
								</p>
								<p class="aj">Transfer to Piraeus for embarkation on the cruise boat. Then sail for the island of Hydra where you have time for strolling, shopping or swimming. In the early afternoon sail for the island of Aegina, passing through the narrow strait separating the Peloponnesian Coast from the island of Poros. Lunch is served during or after sailing. Upon arrival in Aegina you can either join the optional extra excursion to Temple of Aphaia or walk around on your own in the town or enjoy a swim, if the weather permits. Around 6pm embark for the return voyage. Overnight in Athens.</p>					
									<p><b>Meals : </b> Meals: Breakfast+Lunch</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 10:</b> Departure to native
								</p>
								<p class="aj">Breakfast, check-out and per your international flight departure time meet at the hotel for transfer to Athens Airport.</p>					
									<p><b>Meals : </b> Meals: Breakfast</p>
								</td>
								</tr>
								</table>					
								</div>						<br />
												 <p class="headHr p7px b pl10px xlarge">Tour Detail</p>
			             <div class="data p15px aj">
										
						<p class="large b mb5px dif">Inclusions :</p>
						<ul>
															<li>Hotel</li>
																		<li>Sightseeing</li>
																		<li>Transport</li>
																		<li>Transfers</li>
															</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Items of a  personal nature</li><li>
Gratuities for Driver & Guide</li><li>
Meals not mentioned</li><li>
Drinks of any kind</li></ul><br />
												<p class="large b mb5px dif">Specific Departure Dates :</p>JULY, AUGUST, SEPTEMBER<br />
												<p class="large b mb5px dif">Departure Cities with rates :</p>Preferably from Chennai- For customized tour as per the customer's convenience.<br /><br />
											
						<p class="large b mb5px dif">Terms &amp; Conditions :</p>~^#^~~^#^~<p><strong>GENERAL TERMS &amp; CONDITIONS</strong>

<ul>
	<li>All the packages provides twin/triple Sharing&nbsp; AC /Non Ac Rooms as per the mention in the packages.</li>
	<li>South / North indian&nbsp; Veg/ Non veg buffetmeals will be provided . The packet lunch will be given for customers,where&nbsp; the spot meals can not be provided during the travel</li>
	<li>Sos traders will not be held responsible for the misbehaviours/damage caused by the individual while on the tour</li>
	<li>Sostraders advise all the customer to buy travel insurance&nbsp; additionally through sostraders sales desk agent before departuring the tour.</li>
	<li>Comfortable transportation will be given on the private/SIC through car/Van/Minibus/Bus depending upon the customer group size for the particular package.</li>
	<li>Sos traders has got full right to change the Itineraries for the required circumstances. The changes in cost and itineraries will informed immediately. Amount will be refunded according to the refund policy if raised by customer</li>
	<li>Probelems faced by the customers should be informed immediately to the hotel/transport provider/tour manager/sostraders.</li>
	<li>No boarding, drinks and beverages wll be given during the train/Flight travel as per package category</li>
	<li>All the customers who are under group tour not allowed to go seperately or extending the tour without proper intimation.</li>
	<li>For Train transport only sleeper class is included in all the packages. unless other wise if the customer shows specific interest to have Secon/third AC tier will be given with extra charges only.</li>
</ul>

<p><strong>EXCLUDED</strong>

<ul>
	<li>Entrance fee for Adventure, watersport,park,cable&nbsp;&nbsp; car, winter cloth,Rental, laundryetc. Auto, local&nbsp; transport, beverages and drinks during Bus/ Train&nbsp; travels except the item mention in the package</li>
</ul>

<p><strong>CANCELLATION POLICY</strong>

<ul>
	<li>No refund of Advance if cancelled by individual</li>
	<li>7days before 10% of tour amount refunded</li>
	<li>15 days before 50% of tour amount refunced</li>
	<li>30 days before 100% minusing the advance amount</li>
	<li>will refunded</li>
</ul>

<p style="line-height: 20.8px;">Booking Advance

<ul style="line-height: 20.8px;">
	<li>Book your ticket by paying advance amount of Rs.5000 through our website www.shareoursource.in &nbsp;with details of payment</li>
</ul>

<p>&nbsp;						
    	<p class="h dif xlarge b mb5px">Turkey & Greece Tour</p>
    	<div class="otherDetails aj">9 Nights and 10 Days</div><br>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Starts from USD1306</td>
			</tr>
		</table></div><br>						</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.shareoursource.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Turkey & Greece Tours Tour - Tour Package"/>
						<input type="hidden" name="allocate_type" value="tour"/>
						<a href="#" onclick="document.getElementById('frmpackagedetail').submit();" class="button p7px pl12px pr12px c5px b large dib mt10px">Book Your Tour</a>
						<input type="hidden" name="pkg_slno" value="63384"/>
						</form>
						</div>
						
						";i:1;s:66:"Book Turkey & Greece Tours Tour - 9 Nights / 10 Days Tour Packages";i:2;s:131:"book turkey & greece tours tour - 9 nights / 10 days tour packages, heritage tour packages, athens, istanbul, ephesus tour packages";i:3;s:172:"Share Our Source Traders offers Turkey & Greece Tours Tour - 9 Nights / 10 Days tour package, budget Heritage tour packages for Athens, Istanbul, Ephesus at exciting price.";i:4;s:1415:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Athens, Istanbul, Ephesus"        
		                 },
		      "description": "SIGHTSEEING TOURS
05 days Private touring in Turkey starting from in the morning of day 02 ending on afternoon of day 06  includes the following: Professional English speaking guide licensed by Ministry of Tourism
Transport in A/C Tour coach ( 46 Seaters) Main entrance fees to sights visited, Lunch.
Half day Athens sightseeing tour including Acropolis Museum & Entrance fees 
Full day Delphi tour with lunch  with  English Guide  including Entrance fees 
Full day cruise to Hydra Poros Aegina  with lunch ( private transfers ) 
Airport transfers in Istanbul on international arrival & departure
All Transfers & Tours Private with Modern A/C Bus 50 seats in Greece

TRANSPORTATION
01 domestic flight : Istanbul to Kayseri  
Oneway flight from Izmir to AthensFull payment at the time booking –Discount  INR 1000 per person
Group Size more than 15 – Discount INR 2000 per personItems of a  personal nature
Gratuities for Driver & Guide
Meals not mentioned
Drinks of any kind",
		      "name": "Turkey & Greece Tours Tour",
		      "telephone": "+91-9444728610"
		    }
		    </script>
			";i:5;N;}