a:6:{i:0;s:9805:"				<div class="h1"><h1>Phuket Adventure Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.geetcompany.com/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.geetcompany.com/holiday-tour-packages.htm" title="Holiday Tour Packages">Holiday Tour Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Phuket Adventure Tour</p>
				<br />
				
									<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>
					
					<table class="w100 formTable imgWidth">
					<tr>
					
											<td class="p10px vat imgWidth150 w150px">
						<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_1/22362/56496.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_1/22362/56496.jpg"  width="150" height="150"    alt="Phuket Adventure Tour" title="Phuket Adventure Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											
					<td class="p10px">
											<p class="mb5px"><b>Tour Code :</b> 302</p>
												<p class="mb5px"><b>Duration :</b> 
						4 Nights / 5 Days 
						</p>
												<p class="mb5px"><b>Destination Covered :</b> Phuket</p>
												<p><b>Price (Starting From) :</b>						
						INR 13499 Per Person						</p>
												<br />
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.geetcompany.com/travel-inquiry.htm">
						<input type="hidden" name="subject" value="Phuket Adventure Tour - Tour Package"/>
						<input type="hidden" name="allocate_type" value="tour"/>
						<a href="#" onclick="document.getElementById('frmpackagedetail').submit();" class="buttonBig p10px20px c5px b large dib">Book Your Tour</a>
						<input type="hidden" name="pkg_slno" value="28538"/>
						</form>
						</p>
											</td>
					</tr>
					</table>
											<div class="mt7px dif">* Mentioned prices may vary depending upon date of travel, hotel availability, surge pricing and seasonal rush.</div>
											<br />
					
					<div class="packageTabs myTabs horizontal mc"><!--MY TABS STARTS-->
					<ul class="fo lsn m0px p0px">
					
											<li id="tab2"><a href="#data2">Itinerary</a></li>
												<li id="tab4"><a href="#data4">Tour Detail</a></li>
												<li id="tab6"><a href="#data6">Terms &amp; Conditions</a></li>
											</ul>
					
					
											<div class="ic bdr" id="data2"><!--DATA2 START-->
						<br />
						<ul class="lsn m0px p0px">
									<li>
									<p class="b mb5px">Day 1: Phuket
									</p>
									<div class="data p10px">First you arrive at Bangkok. After custom clearance, visa processing and baggage claim, take a connecting flight to Phuket. On your arrival at Phuket Airport, Local Tour representative will welcome and transfer you to the hotel. Depending on the hotels location, the drive will take some time and you can enjoy first glances of the island paradise. Check- in at the hotel and relax. Rest of the day is at leisure. In the evening, you can opt for Phuket Fantasea Show (at an additional cost). It would be a fun filled trip and a good window to see the beautiful Thai traditions and culture while enjoying various carnivals, games and live performances. Return to the hotel stay overnight at the hotel.</div>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 2: Day Is Free For Leisure
									</p>
									<div class="data p10px">A morning is best started with a majestic view of the surroundings followed with a hearty breakfast. Get ready and set off for a Phuket City tour to cover the city landmarks. After the tour, rest of the day is at leisure. You can relax at your hotel or you can explore Phukets exotic beaches. Crowded or secluded, you'll get what you want. Indulge in exciting water sports or enjoy a relaxed swim or snorkeling in the sea. Return to the hotel stay overnight at the hotel.</div>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 3: Day Is Free For Leisure
									</p>
									<div class="data p10px">After a morning bed tea, refresh and recharge yourself with a fill at breakfast. The day is free at your own leisure. Spend it in your own way or take an optional tour to Phi Phi Island (at an additional cost). Koh Phi Phi is one of the major sightseeing tours in Phuket to enjoy sea sports like snorkeling and scuba diving. After the trip, return to your hotel and relax. This would be your last night in Phuket so you can also go for exploring the nightlife of Phuket. Return to the hotel stay overnight at the hotel.</div>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 4: Day Is Free For Leisure
									</p>
									<div class="data p10px">After a morning bed tea, refresh and recharge yourself with a fill at breakfast. The day is free at your own leisure. Spend it in your own way or take an optional tour to James Bond Island tour (at an additional cost) and cruise the Phang Nga Bay is the second most popular activity in the region. The area is situated 25 km north-east of Phuket. It consists of numerous dramatic limestone cliffs rising sheer out of the waters. The most famous one being James Bond Island with its needle formed limestone rock which featured in the James Bond movie "The Man with the Golden Gun". Return to the hotel stay overnight at the hotel.</div>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 5: Departure From Phuket
									</p>
									<div class="data p10px">Breakfast in the hotel. Check Out from the hotel & get transferred to the Airport to catch your Return flight.</div>					
									</li>
									<br />					
							</ul>						<!--DATA2 EMD--></div>
											
						<div class="ic bdr" id="data4"><!--DATA4 START-->
						<br />
						Phuket is a diverse and fascinating island to explore. A rich culture, a beautiful coastline, spectacular natural sights, loads of outdoor sports and activities, shopping, nightlife and dining are just a few of its attractions. Just offshore are dozens of smaller islands, easily reached by boat. The natural wonders of the mainland, found just beyond Phuket over the bridge to the north of the island, are also close at hand.Thailand Visa will be granted on arrival and its chargeable at 1000/1200 Baht per person.<br />
Thailand visa if required from Delhi at INR 3000 per person.<br />
Original passport valid for 6 months from the date of returning<br />
2 photographs white background size 35 x 45mm on matt finish with 80% face  latest (person must be wearing colored clothes)<br />
Bank statement for 6 months with stamp and sign on it or credit card copy<br />
06 Months statement or  forex bill minimum 700 $<br />
Request letter stating the purpose of visit<br />
Photo id card or visiting card if employed<br />
Confirm hotel voucher<br />
Confirm return air ticket.<br />
EXCLUSIONS<br />
Roundtrip Economy class airfare from your home destination.<br />
Any Meals other than specified in inclusions.<br />
Personal expenses such as tips, porterage, telephone calls, rooms service, etc.<br />
Surcharge will be applicable on particular events, Festival, exhibition & Fairs.<br />
Any Security deposit asks by the hotel’s reception during check in at Hotel.<br />
Travel Insurance.<br />
GST - 3.09% extra01-0920-12							<p class="b mb5px dif">Inclusions :</p>
							<ul>
																	<li>Hotel</li>
																				<li>Transfers</li>
																	</ul>
							<br />
														<p class="b mb5px dif">Exclusions :</p> <ul><li>Thailand Visa will be granted on arrival and its chargeable at 1000/1200 Baht per person.</li><li>
Thailand visa if required from Delhi at INR 3000 per person.</li><li>
Original passport valid for 6 months from the date of returning</li><li>
2 photographs white background size 35 x 45mm on matt finish with 80% face  latest (person must be wearing colored clothes)</li><li>
Bank statement for 6 months with stamp and sign on it or credit card copy</li><li>
06 Months statement or  forex bill minimum 700 $</li><li>
Request letter stating the purpose of visit</li><li>
Photo id card or visiting card if employed</li><li>
Confirm hotel voucher</li><li>
Confirm return air ticket.</li><li>
EXCLUSIONS</li><li>
Roundtrip Economy class airfare from your home destination.</li><li>
Any Meals other than specified in inclusions.</li><li>
Personal expenses such as tips, porterage, telephone calls, rooms service, etc.</li><li>
Surcharge will be applicable on particular events, Festival, exhibition & Fairs.</li><li>
Any Security deposit asks by the hotel’s reception during check in at Hotel.</li><li>
Travel Insurance.</li><li>
GST - 3.09% extra</li></ul><br />
													<!--DATA4 EMD--></div>
												<div class="ic bdr" id="data6"><!--DATA6 START-->
						<br />
						* Some Advance Percentage of total booking amount * Airfare/Transport fare to be paid full at one time in advance.~^#^~* Upon cancellation, refund will be made after deducting the Retention Amount. * Retention Amount varies as per the number of days left before your package start date. ~^#^~						<!--DATA6 EMD--></div>
											
					<!--MY TABS END--></div>
					";i:1;s:60:"Book Phuket Adventure Tour - 4 Nights / 5 Days Tour Packages";i:2;s:115:"book phuket adventure tour - 4 nights / 5 days tour packages, beach and islands tour packages, phuket tour packages";i:3;s:161:"Book Phuket Adventure Tour - 4 Nights / 5 Days tour packages from Geet & Company - Get attractive 4 Nights / 5 Days Beach and Islands  tour packages for  Phuket.";i:4;s:1842:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Phuket"        
		                 },
		      "description": "Phuket is a diverse and fascinating island to explore. A rich culture, a beautiful coastline, spectacular natural sights, loads of outdoor sports and activities, shopping, nightlife and dining are just a few of its attractions. Just offshore are dozens of smaller islands, easily reached by boat. The natural wonders of the mainland, found just beyond Phuket over the bridge to the north of the island, are also close at hand.Thailand Visa will be granted on arrival and its chargeable at 1000/1200 Baht per person.
Thailand visa if required from Delhi at INR 3000 per person.
Original passport valid for 6 months from the date of returning
2 photographs white background size 35 x 45mm on matt finish with 80% face  latest (person must be wearing colored clothes)
Bank statement for 6 months with stamp and sign on it or credit card copy
06 Months statement or  forex bill minimum 700 $
Request letter stating the purpose of visit
Photo id card or visiting card if employed
Confirm hotel voucher
Confirm return air ticket.
EXCLUSIONS
Roundtrip Economy class airfare from your home destination.
Any Meals other than specified in inclusions.
Personal expenses such as tips, porterage, telephone calls, rooms service, etc.
Surcharge will be applicable on particular events, Festival, exhibition & Fairs.
Any Security deposit asks by the hotel’s reception during check in at Hotel.
Travel Insurance.
GST - 3.09% extra01-0920-12",
		      "name": "Phuket Adventure Tour",
		      "telephone": "+91-9896771268"
		    }
		    </script>
			";i:5;N;}