a:6:{i:0;s:28144:"				<div class="h1"><h1>Adorable Kerala Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.grandindiatrip.com/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.grandindiatrip.com/tour-packages.htm" title="Tour Packages">Tour Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Adorable Kerala 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">Budget Tour</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Duration </td>
						<td class="p5px pl0px vat">
						5 Nights / 6 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Kochi, Thekkady, Alleppey, Munnar</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 10550 Per Person						</td>
						</tr>
												<tr>
						<td class="b p5px dif w125px vat">Special Offer </td>
						<td class="p5px pl0px dif vat">Holiday Highlight<br />
Sightseeing at Munnar and Cochin and visit Cheyyappara water falls<br />
Best Time to Visit<br />
Kerala weather can be summarized into winter, summer and monsoon. The winter period is from October to February. The climate at this point in Kerala is moderate and pleasant. Summer is generally in between March and May and the climate is hot and humid at this time of the year. During monsoons that lie between June and September, the atmosphere is rainy and windy. Winter is the best and peak season because it has pleasant climatic conditions with respect to any other state of India. Since the temperature drops down slightly, climatic conditions remain a bit mild and pleasant. It is therefore the most preferable time to enjoy at the beaches, backwaters and the hills of Kerala. Winter period of Kerala is also the best time to witness some of the greatest Hindu festivals of the country, Christmas eve celebration and traditional festivals and customs. One feels like a true Keralite during this time of the year because of all the occasions happening in and around the place. If you're planning for a tour in Kerala, book your hotel rooms and/or airline/train tickets in advance so that you can witness God's own country's magic at its best. Best time for heavy discounts and budget holidays in Kerala is during the summer. The climate remains hot and humid at this time but the hill stations of Munnar and Thekkady are pleasant at this time. Kerala during monsoon is best for Ayurvedic Treatment. The preferred time to visit Kerala is during April and October.<br />
Preferred months : April, May, June, July, August, September<br />
Description<br />
With the Arabian Sea in the west, the Western Ghats towering 500-2700 ms in the east and networked by 44 rivers, Kerala enjoys unique geographical features. This has made it one of the most sought after destinations in Asia. An equable climate, long shoreline with serene beaches, tranquil stretches of emerald backwaters, lush green hill stations, exotic wildlife, cool waterfalls, sprawling plantations and paddy fields are what define Kerala. Apart from these, the Ayurvedic health holidays, enchanting art forms, magical festivals, historic and cultural monuments, and mouth watering cuisine, all add up as delights of the place. These charming destinations offer a unique experience and are located at a distance of just two hour drive from each other. This is a singular advantage that no other destinations offer. The beautiful palm fringed beaches of Kovalam and Varkala and the majesty of the undulating hills of Munnar and Vagamon are some of the many reasons to visit the heavenly land of Kerala. The serenity of the pristine backwaters of Kumarakom and Kuttanad and the enchanting woods and forests of Thekkady and Silent Valley will have you bowled over again and again and again.</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.grandindiatrip.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Adorable Kerala 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="70426"/>
						</form>
						</p>
						</td>
						</tr>
											</table>
					</td>
											<td class="p10px vat imgWidth150 w150px lh0">
						<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_9/257644/127616.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/127616.jpg"  width="150" height="150"    alt="Adorable Kerala" title="Adorable Kerala" /></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_9/257644/127617.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/127617.jpg"  width="150" height="150"    alt="Adorable Kerala Tour" title="Adorable Kerala 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_9/257644/127618.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/127618.jpg"  width="150" height="150"    alt="Adorable Kerala Tour" title="Adorable Kerala 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_9/257644/127619.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/127619.jpg"  width="150" height="150"    alt="Adorable Kerala Tour" title="Adorable Kerala 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_9/257644/127620.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/127620.jpg"  width="150" height="150"    alt="Adorable Kerala Tour" title="Adorable Kerala 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_9/257644/127621.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/127621.jpg"  width="150" height="150"    alt="Adorable Kerala Tour" title="Adorable Kerala Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					Cochin<br />
Kochi (colonial name Cochin) is a vibrant city situated on the south-west coast of the Indian peninsula in the breathtakingly scenic and prosperous state of Kerala, hailed as 'God's Own Country'. Its strategic importance over the centuries is underlined by the sobriquet Queen of the Arabian Sea. Informally, Cochin is also referred to as the Gateway to Kerala.<br />
Munnar<br />
The hill station of Munnar is situated in the Idukki District in the eastern part of Kerala, bordering the state of Tamil Nadu. Popularly known as Kashmir of the South.Munnar is located amidst mist-covered mountain ranges and evergreen forests of the Western Ghats.The name Munnar was aptly given to this place since it is located at the convergence of three rivers, which are Mudrapuzha, Nallathani and Kundala.<br />
Alleppey<br />
Alleppey, also known as Alappuzha is often called as "Venice of east" because of its numerous waterways. These huge networks of lagoons, canals, and lakes are the lifeline of Alleppey.Alleppey the ideal headquarters for backwater tourism as well as for visits to the lovely church filled town of Kottayam, and the town of Aranmula, famous for its historic Aranmula Snake Boat Race which is an annual event. Alleppey is also known for its spectacular snake - boat races held on the second Saturday of August, every year. This competition - the Nehru boat race takes its name from India's first prime minister Jawaharlal Nehru, who inaugurated in 1952. It is excitement all around as snake - boats , each manned by over a hundred oarsmen, cut through the waters like wind.<br />
Thekkady<br />
Thekkady is stationed at the Idukki district of Kerala.Thekkady is unique and abundantly rich with flora, fauna and a wide range of birds.The very sound of the word Thekkady conjures up images of elephants, unending chains of hills and spice-scented plantations. In the Periyar forest of Thekkady is one of the finest wildlife reserves in India and spread across the entire district are picturesque plantations and hill towns that hold great apportunities for treks and mountain walks.Holiday Highlight<br />
Sightseeing at Munnar and Cochin and visit Cheyyappara water falls<br />
Best Time to Visit<br />
Kerala weather can be summarized into winter, summer and monsoon. The winter period is from October to February. The climate at this point in Kerala is moderate and pleasant. Summer is generally in between March and May and the climate is hot and humid at this time of the year. During monsoons that lie between June and September, the atmosphere is rainy and windy. Winter is the best and peak season because it has pleasant climatic conditions with respect to any other state of India. Since the temperature drops down slightly, climatic conditions remain a bit mild and pleasant. It is therefore the most preferable time to enjoy at the beaches, backwaters and the hills of Kerala. Winter period of Kerala is also the best time to witness some of the greatest Hindu festivals of the country, Christmas eve celebration and traditional festivals and customs. One feels like a true Keralite during this time of the year because of all the occasions happening in and around the place. If you're planning for a tour in Kerala, book your hotel rooms and/or airline/train tickets in advance so that you can witness God's own country's magic at its best. Best time for heavy discounts and budget holidays in Kerala is during the summer. The climate remains hot and humid at this time but the hill stations of Munnar and Thekkady are pleasant at this time. Kerala during monsoon is best for Ayurvedic Treatment. The preferred time to visit Kerala is during April and October.<br />
Preferred months : April, May, June, July, August, September<br />
Description<br />
With the Arabian Sea in the west, the Western Ghats towering 500-2700 ms in the east and networked by 44 rivers, Kerala enjoys unique geographical features. This has made it one of the most sought after destinations in Asia. An equable climate, long shoreline with serene beaches, tranquil stretches of emerald backwaters, lush green hill stations, exotic wildlife, cool waterfalls, sprawling plantations and paddy fields are what define Kerala. Apart from these, the Ayurvedic health holidays, enchanting art forms, magical festivals, historic and cultural monuments, and mouth watering cuisine, all add up as delights of the place. These charming destinations offer a unique experience and are located at a distance of just two hour drive from each other. This is a singular advantage that no other destinations offer. The beautiful palm fringed beaches of Kovalam and Varkala and the majesty of the undulating hills of Munnar and Vagamon are some of the many reasons to visit the heavenly land of Kerala. The serenity of the pristine backwaters of Kumarakom and Kuttanad and the enchanting woods and forests of Thekkady and Silent Valley will have you bowled over again and again and again.3.50% Government service tax extra.<br />
Any Air or train fare. Monument fee / Camera fee.<br />
Kind of Personal Expenses or Optional Tours/Meals other than specified.<br />
Cost does not include any other thing apart from the itinerary inclusions.<br />
Transportation as per itinerary only (not available at disposal).<br />
Medical Travel insurance.<br />
Surcharges applicable during Festival, Peak Season & Special Events.<br />
Any Increase/Changes in the taxes levied by Govt.<br />
Any cost arising due to natural calamities like, landslides, roadblocks etc (to be borne by the clients directly on the spot).20-0931-03<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> Arrival at Cochin
								</p>
								<p class="aj">Our friendly representative welcomes you at Cochin Airport or Railway Station and helps you proceed to Munnar. It is called as Nature Lovers Paradise and is at 1800 metres above the sea level. On the way to Munnar, youll visit the Cheeyappara waterfalls. Check-in to hotel/resort and enjoy an overnight stay at the Munnar hotel.</p>
								</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 <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_9/257644/127616.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/127616.jpg"  width="150" height="150"    alt="Adorable Kerala" title="Adorable Kerala" /></a></p></div></li>
									</ul>
									</div>
									</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> Sightseeing at Munnar
								</p>
								<p class="aj">After breakfast, tour proceeds for Munnar sightseeing. A morning visit to Eravikulam National Park is sure to refresh you. In the afternoon, visit Mattupetty Dam/Kundala dam for boating, Eco point and Tata Tea museum. Evening at leisure. Overnight stay at Munnar hotel.</p>
								</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 <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_9/257644/127617.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/127617.jpg"  width="150" height="150"    alt="Adorable Kerala Tour" title="Adorable Kerala Tour" /></a></p></div></li>
									</ul>
									</div>
									</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 (90 kms. / 1-2 hrs)
								</p>
								<p class="aj">Checkout from the hotel/resort after breakfast and proceed to Thekkady. Check-in to hotel/resort. Sightseeing of Thekkady: Go for Plantation Tour, Evening boat ride to National Park. Shop around during evening marked for personal leisure time. The day completes with an overnight stay at Thekkady.</p>
								</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 <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_9/257644/127618.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/127618.jpg"  width="150" height="150"    alt="Adorable Kerala Tour" title="Adorable Kerala Tour" /></a></p></div></li>
									</ul>
									</div>
									</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 (139 kms. / 2-3 hrs)
								</p>
								<p class="aj">After breakfast, checkout from the hotel and proceed to Alleppey which has natural beauty in abundance. It is also known as the Venice of the East and is famous for the backwaters, boat races, houseboat holidays, beaches, marine products and coir products. Check-in at your hotel and visit beach in the evening. End the day with an overnight stay at the hotel.</p>
								</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 <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_9/257644/127619.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/127619.jpg"  width="150" height="150"    alt="Adorable Kerala Tour" title="Adorable Kerala Tour" /></a></p></div></li>
									</ul>
									</div>
									</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 (54 kms. / 1-2 hrs)
								</p>
								<p class="aj">After breakfast, checkout from the hotel so as to proceed to Cochin. Check-in at the hotel/resort once you reach Cochin. The day comprises sightseeing places at Cochin like Dutch Palace, The Jewish Synagogue, St. Francis Church, Chinese fishing nets, Santa Cruz Basilica etc, Also, get to view an array of shops with antiques, fabrics & jewellery. Thereafter, return back to the hotel for an overnight stay.</p>
								</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 <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_9/257644/127620.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/127620.jpg"  width="150" height="150"    alt="Adorable Kerala Tour" title="Adorable Kerala Tour" /></a></p></div></li>
									</ul>
									</div>
									</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> Cochin Departure
								</p>
								<p class="aj">After breakfast, our representative helps you to proceed to the airport /railway station for your departure.</p>
								</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 <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_9/257644/127621.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/127621.jpg"  width="150" height="150"    alt="Adorable Kerala Tour" title="Adorable Kerala Tour" /></a></p></div></li>
									</ul>
									</div>
									</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>Transfers</li>
															</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>3.50% Government service tax extra.</li><li>
Any Air or train fare. Monument fee / Camera fee.</li><li>
Kind of Personal Expenses or Optional Tours/Meals other than specified.</li><li>
Cost does not include any other thing apart from the itinerary inclusions.</li><li>
Transportation as per itinerary only (not available at disposal).</li><li>
Medical Travel insurance.</li><li>
Surcharges applicable during Festival, Peak Season & Special Events.</li><li>
Any Increase/Changes in the taxes levied by Govt.</li><li>
Any cost arising due to natural calamities like, landslides, roadblocks etc (to be borne by the clients directly on the spot).</li></ul><br />
											
						<p class="large b mb5px dif">Terms &amp; Conditions :</p>~^#^~~^#^~<div class="hld_tbhead" style="margin: 0px; padding: 0px 0px 5px; color: rgb(46, 103, 172); font-family: Arial, Helvetica, Tahoma, sans-serif; font-size: 15px; font-weight: bold; box-sizing: border-box;"><strong>terms &amp; Conditions</strong></div>

<ul>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">Price mentioned is on per person basis.</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">Bookings are applicable only on twin sharing basis.</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">Bookings are subject to availability with the hotel.</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">Package rates are subject to change without any prior notice</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;"><b style="box-sizing: border-box;">Vehicle as per the itinerary Not on Disposal.</b></li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">The above package rate is not valid during national holidays, festivals, long weekends, Christmas and New Year.</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">Goibibo.com will provide alternate or similar category of hotel in case the hotel mentioned in program is not available.</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">All cancellations &amp; amendments will be done as per hotel policy.</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">The package cannot be combined with any other offer.</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">The guest must carry photo identification like Passport/Driving License/Voter ID Card IN ORIGINAL at the point of check in at the hotel.</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">Goibibo.com reserves the right to change/modify or terminate the offer any time at its own discretion and without any prior notice.</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">A Surcharge may be levied by the hotel during National Holidays/Festive period/Extended Weekends, New year etc</li>
</ul>						
    	<p class="h dif xlarge b mb5px">Hotel Details Standard</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="data p5px">Price Details</td>
				<td class="data p5px">Base Price</td>
			</tr>
			<tr>
				<td class="data p5px">Single Occupancy :</td>
				<td class="data p5px">Rs. 20250</td>
			</tr>
			<tr>
				<td class="data p5px">Twin Sharing :</td>
				<td class="data p5px">Rs. 10125</td>
			</tr>
			<tr>
				<td class="data p5px">Extra Adult :</td>
				<td class="data p5px">Rs. 3800</td>
			</tr>
			<tr>
				<td class="data p5px">Extra Child :</td>
				<td class="data p5px">Rs. 3800</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Hotel Details Deluxe</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="data p5px">Price Details</td>
				<td class="data p5px">Base Price</td>
			</tr>
			<tr>
				<td class="data p5px">Single Occupancy :</td>
				<td class="data p5px">Rs. 23794</td>
			</tr>
			<tr>
				<td class="data p5px">Twin Sharing :</td>
				<td class="data p5px">Rs. 11897</td>
			</tr>
			<tr>
				<td class="data p5px">Extra Adult :</td>
				<td class="data p5px">Rs. 5000</td>
			</tr>
			<tr>
				<td class="data p5px">Extra Child :</td>
				<td class="data p5px">Rs. 5000</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Hotel Details Luxury</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="data p5px">Price Details</td>
				<td class="data p5px">Base Price</td>
			</tr>
			<tr>
				<td class="data p5px">Single Occupancy :</td>
				<td class="data p5px">Rs. 44415</td>
			</tr>
			<tr>
				<td class="data p5px">Twin Sharing :</td>
				<td class="data p5px">Rs. 22208</td>
			</tr>
			<tr>
				<td class="data p5px">Extra Adult :</td>
				<td class="data p5px">Rs. 9900</td>
			</tr>
			<tr>
				<td class="data p5px">Extra Child :</td>
				<td class="data p5px">Rs. 7000</td>
			</tr>
		</table></div><br>						</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.grandindiatrip.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Adorable Kerala 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="70426"/>
						</form>
						</div>
						
						";i:1;s:59:"Book Adorable Kerala Tour - 5 Nights / 6 Days Tour Packages";i:2;s:136:"book adorable kerala tour - 5 nights / 6 days tour packages, hill station tour packages, kochi, thekkady, alleppey, munnar tour packages";i:3;s:195:"Book Adorable Kerala Tour - 5 Nights / 6 Days tour packages from Grand India Tours & Travels - Get attractive 5 Nights / 6 Days Hill Station  tour packages for  Kochi, Thekkady, Alleppey, Munnar.";i:4;s:5929:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Kochi, Thekkady, Alleppey, Munnar"        
		                 },
		      "description": "Cochin
Kochi (colonial name Cochin) is a vibrant city situated on the south-west coast of the Indian peninsula in the breathtakingly scenic and prosperous state of Kerala, hailed as 'God's Own Country'. Its strategic importance over the centuries is underlined by the sobriquet Queen of the Arabian Sea. Informally, Cochin is also referred to as the Gateway to Kerala.
Munnar
The hill station of Munnar is situated in the Idukki District in the eastern part of Kerala, bordering the state of Tamil Nadu. Popularly known as Kashmir of the South.Munnar is located amidst mist-covered mountain ranges and evergreen forests of the Western Ghats.The name Munnar was aptly given to this place since it is located at the convergence of three rivers, which are Mudrapuzha, Nallathani and Kundala.
Alleppey
Alleppey, also known as Alappuzha is often called as "Venice of east" because of its numerous waterways. These huge networks of lagoons, canals, and lakes are the lifeline of Alleppey.Alleppey the ideal headquarters for backwater tourism as well as for visits to the lovely church filled town of Kottayam, and the town of Aranmula, famous for its historic Aranmula Snake Boat Race which is an annual event. Alleppey is also known for its spectacular snake - boat races held on the second Saturday of August, every year. This competition - the Nehru boat race takes its name from India's first prime minister Jawaharlal Nehru, who inaugurated in 1952. It is excitement all around as snake - boats , each manned by over a hundred oarsmen, cut through the waters like wind.
Thekkady
Thekkady is stationed at the Idukki district of Kerala.Thekkady is unique and abundantly rich with flora, fauna and a wide range of birds.The very sound of the word Thekkady conjures up images of elephants, unending chains of hills and spice-scented plantations. In the Periyar forest of Thekkady is one of the finest wildlife reserves in India and spread across the entire district are picturesque plantations and hill towns that hold great apportunities for treks and mountain walks.Holiday Highlight
Sightseeing at Munnar and Cochin and visit Cheyyappara water falls
Best Time to Visit
Kerala weather can be summarized into winter, summer and monsoon. The winter period is from October to February. The climate at this point in Kerala is moderate and pleasant. Summer is generally in between March and May and the climate is hot and humid at this time of the year. During monsoons that lie between June and September, the atmosphere is rainy and windy. Winter is the best and peak season because it has pleasant climatic conditions with respect to any other state of India. Since the temperature drops down slightly, climatic conditions remain a bit mild and pleasant. It is therefore the most preferable time to enjoy at the beaches, backwaters and the hills of Kerala. Winter period of Kerala is also the best time to witness some of the greatest Hindu festivals of the country, Christmas eve celebration and traditional festivals and customs. One feels like a true Keralite during this time of the year because of all the occasions happening in and around the place. If you're planning for a tour in Kerala, book your hotel rooms and/or airline/train tickets in advance so that you can witness God's own country's magic at its best. Best time for heavy discounts and budget holidays in Kerala is during the summer. The climate remains hot and humid at this time but the hill stations of Munnar and Thekkady are pleasant at this time. Kerala during monsoon is best for Ayurvedic Treatment. The preferred time to visit Kerala is during April and October.
Preferred months : April, May, June, July, August, September
Description
With the Arabian Sea in the west, the Western Ghats towering 500-2700 ms in the east and networked by 44 rivers, Kerala enjoys unique geographical features. This has made it one of the most sought after destinations in Asia. An equable climate, long shoreline with serene beaches, tranquil stretches of emerald backwaters, lush green hill stations, exotic wildlife, cool waterfalls, sprawling plantations and paddy fields are what define Kerala. Apart from these, the Ayurvedic health holidays, enchanting art forms, magical festivals, historic and cultural monuments, and mouth watering cuisine, all add up as delights of the place. These charming destinations offer a unique experience and are located at a distance of just two hour drive from each other. This is a singular advantage that no other destinations offer. The beautiful palm fringed beaches of Kovalam and Varkala and the majesty of the undulating hills of Munnar and Vagamon are some of the many reasons to visit the heavenly land of Kerala. The serenity of the pristine backwaters of Kumarakom and Kuttanad and the enchanting woods and forests of Thekkady and Silent Valley will have you bowled over again and again and again.3.50% Government service tax extra.
Any Air or train fare. Monument fee / Camera fee.
Kind of Personal Expenses or Optional Tours/Meals other than specified.
Cost does not include any other thing apart from the itinerary inclusions.
Transportation as per itinerary only (not available at disposal).
Medical Travel insurance.
Surcharges applicable during Festival, Peak Season & Special Events.
Any Increase/Changes in the taxes levied by Govt.
Any cost arising due to natural calamities like, landslides, roadblocks etc (to be borne by the clients directly on the spot).20-0931-03",
		      "name": "Adorable Kerala Tour",
		      "telephone": "+91-9415285186"
		    }
		    </script>
			";i:5;N;}