a:6:{i:0;s:12890:"				<div class="h1"><h1>Cochin - Munnar - Thekkady - Alleppey - Kovalam 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>Cochin - Munnar - Thekkady - Alleppey - Kovalam 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" id="detailslider1">
															<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/2142.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_1/22362/2142.jpg"  width="150" height="150"    alt="Cochin - Munnar - Thekkady - Alleppey - Kovalam Tour" title="Cochin - Munnar - Thekkady - Alleppey - Kovalam Tour" /></a></p></div></li>
																		<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/2143.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_1/22362/2143.jpg"  width="150" height="150"    alt="Cochin - Munnar - Thekkady - Alleppey - Kovalam Tour" title="Cochin - Munnar - Thekkady - Alleppey - Kovalam Tour" /></a></p></div></li>
																		<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/2144.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_1/22362/2144.jpg"  width="150" height="150"    alt="Cochin - Munnar - Thekkady - Alleppey - Kovalam Tour" title="Cochin - Munnar - Thekkady - Alleppey - Kovalam Tour" /></a></p></div></li>
																		<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/2145.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_1/22362/2145.jpg"  width="150" height="150"    alt="Cochin - Munnar - Thekkady - Alleppey - Kovalam Tour" title="Cochin - Munnar - Thekkady - Alleppey - Kovalam Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											
					<td class="p10px">
											<p class="mb5px"><b>Duration :</b> 
						5 Nights / 6 Days 
						</p>
												<p class="mb5px"><b>Destination Covered :</b> Kochi, Kovalam, Thekkady, Alleppey, Trivandrum, Munnar</p>
												<p><b>Price (Starting From) :</b> <span class="dif">On Request</span></p>
												<br />
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.geetcompany.com/travel-inquiry.htm">
						<input type="hidden" name="subject" value="Cochin - Munnar - Thekkady - Alleppey - Kovalam 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="4977"/>
						</form>
						</p>
											</td>
					</tr>
					</table>
										<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="tab5"><a href="#data5">Rate Card</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: Cochin - Munnar (Arrival)
									</p>
									<div class="data p10px">Arrival at Cochin Airport/Railway Station and transfer to Munnar. Munnar is 1800 mts above sea level and also the place of South India's highest peak (Anamudi - 2695 mts). On the way visit Valara, Cheeyappara waterfalls & Tea Plantations. On arrival at Munnar transfer to Hotel. Check in at Hotel. Afternoon visit Rajamala (Eravikulam National Park - open as per the directions by the forest authorities ), the best place to see Nilgiri Tahr (Hermitragus Hilarious) - the mountain goat of South India & Tea Musium. Evening have a short visit at Munnar town. You can see the beautiful tea estates like a green paradise. Overnight stay at Munnar.</div>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 2: Munnar
									</p>
									<div class="data p10px">After breakfast proceed for sightseeing. Maduppatty dam, Echo Point, Kundalay Dam, Pothenmedu View Point, Blossom Park etc are some of the highlights of the sightseeing. Shopping & Overnight stay at Munnar.</div>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 3: Munnar - Thekkady
									</p>
									<div class="data p10px">Morning have breakfast at resort later check out resort and drive to Thekkady. Thekkady is a world famous wildlife sanctuary and it is also called as Periyar. On arrival check in Hotel Afternoon proceed for a game viewing cruise on the Periyar Lake. Here you will be able to see a large variety of wildlife, which include elephants, monkeys, deer, wild boar etc evening you can take a Elephant ride at Periyar wild life and rest of the day is at leisure.</div>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 4: Thekkady - Alleppey (Houseboat)
									</p>
									<div class="data p10px">After breakfast check out from the hotel and transfer to houseboat. Around 1200 hrs check in at the Houseboat and start your cruise through the rich and splendid backwater. Just relax at the deluxe houseboat. It will be a unique and exclusive experience in your lifetime. You will be cruising along the village sides and paddy fields witnessing the core life of the Kerala villages for the whole day. The house boat is fully furnished with bedrooms and a kitchen. Dinner and overnight at the houseboat.</div>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 5: Alleppey - Kovalam
									</p>
									<div class="data p10px">Alleppey - Kovalam - After breakfast check out from the hotel / houseboat and transfer to Kovalam. Check in at Hotel. Kovalam is an evergreen and pleasant climatic beach resort. Kovalam is a dreamland for tourists all over the world. With high rock promontory and a calm bay of blue waters, this beach paradise creates a unique aquarelle on moonlit nights. Kovalam was brought to the public eye by the Maharaja of Travancore. Over the past three decades, the place has been well developed, and now figures prominently on the world tourism map. The warm and clean atmosphere by the coconut trees and the white sandbed are perfect for relaxing holidays, as the sea breeze gently plays with the waves. Relax at the hotel and overnight stay.</div>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 6: Kovalam - Trivandrum (Tour Ends)
									</p>
									<div class="data p10px">Morning have breakfast at resort later check out Hotel and drive to Airport / Railway Station for departure.</div>					
									</li>
									<br />					
							</ul>						<!--DATA2 EMD--></div>
											
						<div class="ic bdr" id="data4"><!--DATA4 START-->
						<br />
						Tour Start Date : 13-06-2012Meals not mentioned in the itinerary.<br />
entry fees to monuments and places.<br />
anything not mentioned in the package includes.<br />
Porter age at hotels and airports, tips, insurance, laundry, liquors, wine.<br />
All items of personal nature.<br />
Any cost arising due to natural calamities like landslides, roadblocks, etc.<br />
Any increase in taxes or fuel leading to an increase in surface transport at.<br />
Non AC rooms only provided in Munnar And Thekkady as hill Stations.							<p class="b mb5px dif">Inclusions :</p>
							<ul>
																	<li>Meals</li>
																				<li>Sightseeing</li>
																				<li>Transfers</li>
																	</ul>
							<br />
														<p class="b mb5px dif">Exclusions :</p> <ul><li>Meals not mentioned in the itinerary.</li><li>
entry fees to monuments and places.</li><li>
anything not mentioned in the package includes.</li><li>
Porter age at hotels and airports, tips, insurance, laundry, liquors, wine.</li><li>
All items of personal nature.</li><li>
Any cost arising due to natural calamities like landslides, roadblocks, etc.</li><li>
Any increase in taxes or fuel leading to an increase in surface transport at.</li><li>
Non AC rooms only provided in Munnar And Thekkady as hill Stations.</li></ul><br />
													<!--DATA4 EMD--></div>
							
						<div class="ic bdr" id="data5"><!--DATA5 START-->
						<br />
						
    	<p class="h dif xlarge b mb5px">Hotel Details</p>
    	<div class="otherDetails aj">Note:-<br>
The Quote Is Subject To Change And No Reservation Has Been Made, This Is Only A Quote.<br>
-Rooms Are Subject To Availability-<br>
The Quoted Amount Inclusive Of All Currently Applicable Taxes.</div><br>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Destination</td>
				<td class="headHr p5px b">Hotels</td>
				<td class="headHr p5px b">Room Type</td>
				<td class="headHr p5px b">Meals Plan</td>
				<td class="headHr p5px b">Number of Rooms</td>
				<td class="headHr p5px b">Extra Bed Adult</td>
				<td class="headHr p5px b">Extra Bed Child</td>
				<td class="headHr p5px b">Child Without Extra Bed</td>
				<td class="headHr p5px b">Nights</td>
			</tr>
			<tr>
				<td class="data p5px">Munnar</td>
				<td class="data p5px">Blu Haze Resort And Spa</td>
				<td class="data p5px">Delux Room</td>
				<td class="data p5px">MAPAI</td>
				<td class="data p5px">3</td>
				<td class="data p5px">1</td>
				<td class="data p5px">0</td>
				<td class="data p5px">0</td>
				<td class="data p5px">2</td>
			</tr>
			<tr>
				<td class="data p5px">Thekkady</td>
				<td class="data p5px">Thekkady Woods</td>
				<td class="data p5px">Standard Room</td>
				<td class="data p5px">MAPAI</td>
				<td class="data p5px">3</td>
				<td class="data p5px">1</td>
				<td class="data p5px">0</td>
				<td class="data p5px">0</td>
				<td class="data p5px">1</td>
			</tr>
			<tr>
				<td class="data p5px">Alleppey</td>
				<td class="data p5px">AC Deluxe Houseboat</td>
				<td class="data p5px">03 Bedroom AC Deluxe Houseboat</td>
				<td class="data p5px">APAI</td>
				<td class="data p5px">3</td>
				<td class="data p5px">1</td>
				<td class="data p5px">0</td>
				<td class="data p5px">0</td>
				<td class="data p5px">1</td>
			</tr>
			<tr>
				<td class="data p5px">Kovalam</td>
				<td class="data p5px">Soma Palm Shore Shore</td>
				<td class="data p5px">Standard Room</td>
				<td class="data p5px">MAPAI</td>
				<td class="data p5px">3</td>
				<td class="data p5px">1</td>
				<td class="data p5px">0</td>
				<td class="data p5px">0</td>
				<td class="data p5px">1</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Package Amount</p>
    	<div class="otherDetails aj">Total Cost for 7 Adults:-</div><br>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="data p5px">Rs.64700.00/-</td>
			</tr>
		</table></div><br>						<!--DATA5 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:91:"Book Cochin - Munnar - Thekkady - Alleppey - Kovalam Tour - 5 Nights / 6 Days Tour Packages";i:2;s:189:"book cochin - munnar - thekkady - alleppey - kovalam tour - 5 nights / 6 days tour packages, hill station tour packages, kochi, kovalam, thekkady, alleppey, trivandrum, munnar tour packages";i:3;s:220:"Geet & Company offers Cochin - Munnar - Thekkady - Alleppey - Kovalam Tour - 5 Nights / 6 Days tour package, budget Hill Station tour packages for Kochi, Kovalam, Thekkady, Alleppey, Trivandrum, Munnar at exciting price.";i:4;s:963:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Kochi, Kovalam, Thekkady, Alleppey, Trivandrum, Munnar"        
		                 },
		      "description": "Tour Start Date : 13-06-2012Meals not mentioned in the itinerary.
entry fees to monuments and places.
anything not mentioned in the package includes.
Porter age at hotels and airports, tips, insurance, laundry, liquors, wine.
All items of personal nature.
Any cost arising due to natural calamities like landslides, roadblocks, etc.
Any increase in taxes or fuel leading to an increase in surface transport at.
Non AC rooms only provided in Munnar And Thekkady as hill Stations.",
		      "name": "Cochin - Munnar - Thekkady - Alleppey - Kovalam Tour",
		      "telephone": "+91-9896771268"
		    }
		    </script>
			";i:5;N;}