a:6:{i:0;s:14329:"				<div class="h1"><h1>Munnar - Thekkady - Alleppey Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="https://www.grandindiatrip.com/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="https://www.grandindiatrip.com/tour-packages.htm" title="Tour Packages">Tour Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Munnar - Thekkady - Alleppey 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">KERALA SUMMER PACKAG</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Duration </td>
						<td class="p5px pl0px vat">
						4 Nights / 5 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Thekkady, Alleppey, Munnar</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 8999 Per Person						</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="https://www.grandindiatrip.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Munnar - Thekkady - Alleppey 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="58179"/>
						</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_9/257644/110221.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/110221.jpg"  width="150" height="150"    alt="Munnar - Thekkady - Alleppey Tour" title="Munnar - Thekkady - Alleppey Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					Kerala is the most popular honeymoon destination in India, particularly because of its romantic resorts on the beaches, backwaters and hill stations..<br />
2N Munnar – 1N Thekkady – 1N AlleppeyAny meals other than those mentioned above.<br />
Any Airfare / Train fare.<br />
Entrance fees to Amusement parks & Boating charges.<br />
Any portage at airports and hotels, tips, insurance, wine, mineral water, telephone charges, and all items of personal nature.<br />
Any services not specifically mentioned in the inclusions.<br />
Expenses caused by factors beyond our control like rail and flight delays, roadblocks, vehicle malfunctions,political disturbances etc.15-0430-06<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> Cochin - Munnar (158 kms. - 04 hrs.)
								</p>
								<p class="aj">Upon arrival our representative will greet you at Kochi Airport/Railway Station. Later proceed to Munnar, which is breathtakingly beautiful, a haven of peace and tranquility - the idyllic tourist destination in God's own country. On the way you can also watch the adorable waterfalls in Cheeyappara and colourful flowers in Blossom Garden. Explore rest of the day along with the nature. Overnight stay at the Hotel/Resort.</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> Munnar
								</p>
								<p class="aj">After breakfast proceed for a morning sightseeing trip of Munnar visiting the Eravikulam National Park where you can see the very rare mountain goats natively called the Nilgiri Tahr. Visit Tea Museum and Mattupetty Lake & Dam & Kundala Lake. Enroute visit Echo Point, View Point & green carpet of Tea Gardens. Overnight stay at Munnar Hotel/Resort.</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> Munnar - Thekkady (110 kms. - 03 hrs.)
								</p>
								<p class="aj">After breakfast proceed to Thekkady which offers diverse attractions like Periyar Wildlife Sanctuary, Hill Station and Spice Plantation. Here you can go for a Wildlife cruise to view a large variety of wildlife like Wild Elephants, Nilgiri Langur, Sambar Deer, Wild Bison and quite a lot of unique birds can also be spotted. You can recreate yourself by indulging in optional (chargeable basis) activities like Spice Plantation Tour, Bamboo Rafting, Trekking and Elephant ride. Overnight stay at the Hotel/Resort.</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> Thekkady - Alleppey (130 kms. - 04 hrs.)
								</p>
								<p class="aj">After breakfast, check-out and proceed to Alleppey. Alleppey with a large network of inland canals earning it the sobriquet "Venice of the East". These large networks of canals with spectacular Backwaters, Beaches, Marine products & Coir industry provide Alleppey its lifeline. Evening enjoy the sunset at Alleppey Beach. Overnight stay at Alleppey Hotel/Resort. <br />
If Houseboat Stay:<br />
After breakfast proceed to Alleppey boat Jetty, board the traditionally decorated houseboats and begin the enchanting backwater cruise. The backwaters of Kerala is a unique product of Kerala and is found no where else in the world. A glide in a "Kettuvallam" (Houseboat) through the enchanting backwater is sure to rob your heart. Lunch, Dinner & Overnight stay at Alleppey Houseboat.</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> Alleppey - Cochin (100 kms. - 2.5 hrs.)
								</p>
								<p class="aj">After the breakfast pack your baggages with a promise to return once again to this paradise.... Proceed on time to board your flight/train with sweet memories of your holidays. We await for your next visit ... Bon Voyage. Service ends.</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>
															</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Any meals other than those mentioned above.</li><li>
Any Airfare / Train fare.</li><li>
Entrance fees to Amusement parks & Boating charges.</li><li>
Any portage at airports and hotels, tips, insurance, wine, mineral water, telephone charges, and all items of personal nature.</li><li>
Any services not specifically mentioned in the inclusions.</li><li>
Expenses caused by factors beyond our control like rail and flight delays, roadblocks, vehicle malfunctions,political disturbances etc.</li></ul><br />
												<p class="large b mb5px dif">Specific Departure Dates :</p>lease Note<br />
At Munnar & Thekkady, A/c rooms are not provided due to low temp.<br />
Peak season Supplementary cost for Munnar hotel in Economy Category would be Rs. 250 Per Person from 16 April to 10 June 2016 would be applicable.<br />
Supplementary cost for Ac Dlx. Houseboat instead of hotels at Economy, Standard, Deluxe & Superior Category would be Rs. 2,200/- Per Person & Ac Premium Houseboat @ 3500 Per Person.<br />
Supplementary cost for Ac Premium Houseboat instead of Alleppey hotel at Premium category @ 3500 Per Person.<br />
At Hotel Check-in time is 14.00 hrs & / Check-out time 12.00 Noon.<br />
Early check in and late checkout subject to availability.<br />
At Houseboat Check-in time is 12.00 hrs. & Check-out time is 09.00 hrs.<br />
In A/C Deluxe category Houseboat, A/C will be operational from 9:00 P.M. to 6:00 A.M.<br />
In A/C Premium category Houseboat, A/C will be operational as per your requirements.<br />
All houseboat become standstill from 5.30 pm to 8.00 am next day due to Govt. restrictions.<br />
The above rates are valid for the mentioned period only and subject to change without any prior notice.<br />
											
						<p class="large b mb5px dif">Terms &amp; Conditions :</p>* 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. ~^#^~						
    	<p class="h dif xlarge b mb5px">Rate Card</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Hotel /Category</td>
				<td class="headHr p5px b">Min. 2 Pax</td>
				<td class="headHr p5px b">Min. 4 Pax</td>
				<td class="headHr p5px b">Min. 6 Pax</td>
				<td class="headHr p5px b">Extra Bed</td>
			</tr>
			<tr>
				<td class="headVr p5px">Economy</td>
				<td class="data p5px">8,999/-</td>
				<td class="data p5px">6,749/-</td>
				<td class="data p5px">5,649/-</td>
				<td class="data p5px">3,249/-</td>
			</tr>
			<tr>
				<td class="headVr p5px">Standard</td>
				<td class="data p5px">9,399/-</td>
				<td class="data p5px">7,149/-</td>
				<td class="data p5px">6,049/-</td>
				<td class="data p5px">3,249/-</td>
			</tr>
			<tr>
				<td class="headVr p5px">Deluxe</td>
				<td class="data p5px">10,749/-</td>
				<td class="data p5px">8,549/-</td>
				<td class="data p5px">7,399/-</td>
				<td class="data p5px">3,449/-</td>
			</tr>
			<tr>
				<td class="headVr p5px">Superior</td>
				<td class="data p5px">13,099/-</td>
				<td class="data p5px">10,849/-</td>
				<td class="data p5px">9,749/-</td>
				<td class="data p5px">4,149/-</td>
			</tr>
			<tr>
				<td class="headVr p5px">Premium</td>
				<td class="data p5px">15,399/-</td>
				<td class="data p5px">13,149/-</td>
				<td class="data p5px">12,049/-</td>
				<td class="data p5px">4,899/-</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Hotels Detail</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Destination / Hotels</td>
				<td class="headHr p5px b">Economy</td>
				<td class="headHr p5px b">Standard</td>
				<td class="headHr p5px b">Deluxe</td>
				<td class="headHr p5px b">Superior</td>
				<td class="headHr p5px b">Premium</td>
			</tr>
			<tr>
				<td class="headVr p5px">Munnar</td>
				<td class="data p5px">Spice Country Resort</td>
				<td class="data p5px">Green Ridge Holiday Home</td>
				<td class="data p5px">Elysium Garden Hill Resort</td>
				<td class="data p5px">Broad Bean Resort & Spa</td>
				<td class="data p5px">Sterling’s Terrace Green Resort</td>
			</tr>
			<tr>
				<td class="headVr p5px">Thekkady</td>
				<td class="data p5px">Seasons Thekkady</td>
				<td class="data p5px">Grand Thekkady</td>
				<td class="data p5px">Peppervine</td>
				<td class="data p5px">Holiday Vista</td>
				<td class="data p5px">The Elephant Court</td>
			</tr>
			<tr>
				<td class="headVr p5px">Alleppey</td>
				<td class="data p5px">Pagoda Resort</td>
				<td class="data p5px">Arcadia Regency</td>
				<td class="data p5px">Backwaters Resort</td>
				<td class="data p5px">The World Backwaters Resort</td>
				<td class="data p5px">Lake Palace Resort</td>
			</tr>
		</table></div><br>						</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="https://www.grandindiatrip.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Munnar - Thekkady - Alleppey 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="58179"/>
						</form>
						</div>
						
						";i:1;s:72:"Book Munnar - Thekkady - Alleppey Tour - 4 Nights / 5 Days Tour Packages";i:2;s:136:"book munnar - thekkady - alleppey tour - 4 nights / 5 days tour packages, valley tour packages, thekkady, alleppey, munnar tour packages";i:3;s:195:"Book Munnar - Thekkady - Alleppey Tour - 4 Nights / 5 Days tour packages from Grand India Tours & Travels - Get attractive 4 Nights / 5 Days Valley  tour packages for  Thekkady, Alleppey, Munnar.";i:4;s:1082:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Thekkady, Alleppey, Munnar"        
		                 },
		      "description": "Kerala is the most popular honeymoon destination in India, particularly because of its romantic resorts on the beaches, backwaters and hill stations..
2N Munnar – 1N Thekkady – 1N AlleppeyAny meals other than those mentioned above.
Any Airfare / Train fare.
Entrance fees to Amusement parks & Boating charges.
Any portage at airports and hotels, tips, insurance, wine, mineral water, telephone charges, and all items of personal nature.
Any services not specifically mentioned in the inclusions.
Expenses caused by factors beyond our control like rail and flight delays, roadblocks, vehicle malfunctions,political disturbances etc.15-0430-06",
		      "name": "Munnar - Thekkady - Alleppey Tour",
		      "telephone": "+91-9415285186"
		    }
		    </script>
			";i:5;N;}