a:6:{i:0;s:16766:"				<div class="h1"><h1>My Dream Kerala Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.arihanttours.in/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.arihanttours.in/india-tours.htm" title="India Tours">India Tours</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>My Dream 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">Duration </td>
						<td class="p5px pl0px vat">
						6 Nights / 7 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Kumarakom, Kochi, Thekkady, Alleppey, Munnar</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 17500 Per Person						</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.arihanttours.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="My Dream 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="25203"/>
						</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_1/26194/51210.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_1/26194/51210.jpg"  width="150" height="150"    alt="My Dream Kerala Tour" title="My Dream 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_1/26194/51211.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_1/26194/51211.jpg"  width="150" height="150"    alt="My Dream Kerala Tour" title="My Dream 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_1/26194/51212.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_1/26194/51212.jpg"  width="150" height="150"    alt="My Dream Kerala Tour" title="My Dream Kerala Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					Sandwiched between the tall mountains and deep blue sea, is the South-Western State of Kerala. It is a State, blessed with a long shoreline and serene beaches, emerald backwaters, lushgreen hillstations, aromatic plantations, abundant wildlife, waterfalls, history, culture, monuments, exotic cuisine… No wonder, it is called – ‘God’s Own Country’.Entrance charges anywhere are not included<br />
Expenses of personal nature such as tips, telephone calls, laundry, liquor etc<br />
The package does not include guide services<br />
Air Fare/Train Fare and all entry fees at sightseeing spots<br />
Service Tax 2.58% Extra If Required Bill for claim LTA<br />
The above package is not valid during national holidays, festivals & long weekends<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">Welcome to God?s Own Country, upon arrival our ever smiling representative will greet you and will later escort you to the hotel in Cochin. Check in and relax for a while amidst the comforts of your room. Later, move for a half day city leisurely walk around the city of Cochin. Cochin which is having the best preserved history of colonial times and the ideal way to bring it alive is to take a walk down memory lane. Surrender to the comfort of your bedroom at the hotel for the night as your tour starts the day after.</p>					
									<p><b>Meals : </b> NO MEALS</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> Cochin-Munnar
								</p>
								<p class="aj">Full day sightseeing tour of Cochin will commence in the morning. On today's sightseeing you will get to explore St. Francis Church, Jewish Synagogue and more. Believed to be the oldest church in India, it was built in 1503 by Portuguese Franciscan monks. Jewish Synagogue houses The Great Scrolls of Old Testament. The Mattancherry Palace also known as Dutch Palace features Kerala?s murals displaying Hindu temple art, portraits of former Kings of Kochi. Also watch the Chinese fishing nets in action along the sea front. Conclude the sightseeing trip with a visit to St. Francis Church; the church built in 1503 is the oldest European church in the country and thus is a significant historic monument as well. Moving ahead with the journey you will be escorted to your next destination, Munnar. A scenic hill station nestled in the lap of Mother Nature Munnar is known for its natural beauty, calmness and mild cold climate. On arrival check-in a hotel for your stay in the town.</p>					
									<p><b>Meals : </b> 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 3:</b> Munnar
								</p>
								<p class="aj">Located in the south Western Ghats of India, Munnar is a charming hill station in the Idukki district of Kerala. The land blessed with natural splendor looks dazzling with rocky peaks, rolled mountains, manicured tea gardens and soothing mountain air. Munnar is located at the confluence of Muthirappuzha, Nallathanni and Kundaly rivers. The day at Munnar brings a sightseeing tour of the picturesque environs of the town. Essentially a tea town, Munnar catches the visitor?s attention with its refreshing aroma first and then continues to impress with its beauty and placidity. The sightseeing plan for the day includes visit to pristine Mattupetty Lake and neighboring Swiss Livestock Project, a specialized dairy farm where about 100 varieties of high yielding cattle are reared. The region is worth paying a visit for both its enchanting flora and fauna. Take a stroll around the local markets to pick souvenirs before you return to your hotel in the evening.</p>					
									<p><b>Meals : </b> 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 4:</b> Munnar- Thekkady
								</p>
								<p class="aj">Transfer to Thekkady & check into a wildlife resort. In the afternoon, set on wildlife safari inside Periyar Wildlife Sanctuary that spreads over 777 sq km of landscape. Roughly half of the landscape is dense evergreen forest, savannah grassland and moist deciduous forest. Set on a jeep safari inside Periyar Wildlife Sanctuary situated on the banks of the Periyar Lake. Home to myriad wild creatures this protected area lies in the middle of mountainous region of Cardamom Hills and is cradled with picturesque Periyar Lake. Venture deep inside the park and explore the verdant environs at the care of an expert naturalist. Animals such as elephant, sambar, gaur and wild boars and beauteous bird populations such as darters, cormorants, kingfishers and racket tailed Drongos have made the park their home. Spot these animals coming to the banks of Periyar Lake to quench their thirst while you sail on a boat in the pristine lake. Also, visit a spice plantation in the vicinity later before you return to the hotel for night stay.</p>					
									<p><b>Meals : </b> 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 5:</b> Thekkady- Kumarakom
								</p>
								<p class="aj">On this day you will proceed to Kumarakom, the charming emerald peninsula sticking out into the ever-sparkling Vembanad Lake which will take you into the heart of the scenic land where you'll come across plenty of traditional country crafts, boats and canoes. Morning enjoy a drive down through tea and rubber plantations to reach tranquil Kumarakom. Afternoon at Kumarakom will be free to enjoy the facilities at the hotel. You can enjoy swimming, fishing, go boating or opt for a rejuvenating Ayurvedic massage here (Optional, at additional cost).</p>					
									<p><b>Meals : </b> 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 6:</b> Kumarakom- Alleppey
								</p>
								<p class="aj">Morning depart for Alleppey a town with picturesque canals, backwaters, beaches and lagoons, once described as the list of places known as Venice of the East by Lord Curzon. The most popular destination of Kerala renowned for its angelic beauty and picture perfect looks, this backwaters town is base for most houseboat action in the province. Enjoy backwaters boat ride amidst lush green vegetation at Alleppey. The highlight of the tour will be a journey on the crystal clear backwaters while cruising on a traditional houseboat, Kettuvallam(Optional, at an additional cost). This is undoubtedly the best way to travel across Kerala backwaters for this way one gets to travel at one?s own speed and thus to enjoy the pristine environs of the region completely at peace. Enjoy a comfortable Kettuvallam houseboat for a day cruise. These houseboats now exist in ultra chic style and are comparable to nothing less than floating cottages having ample space and equipped with state-of-the-art amenities ensuring pure luxurious stay amidst most tranquilizing environs of Kerala backwaters</p>					
									<p><b>Meals : </b> 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 7:</b> Alleppey- Cochin- Departure
								</p>
								<p class="aj">Your trip ends back at Cochin where guided by our representative you will reach in time to start your journey back homewards.</p>					
									<p><b>Meals : </b> 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>Transfers</li>
															</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Entrance charges anywhere are not included</li><li>
Expenses of personal nature such as tips, telephone calls, laundry, liquor etc</li><li>
The package does not include guide services</li><li>
Air Fare/Train Fare and all entry fees at sightseeing spots</li><li>
Service Tax 2.58% Extra If Required Bill for claim LTA</li><li>
The above package is not valid during national holidays, festivals & long weekends</li></ul><br />
												<p class="large b mb5px dif">Specific Departure Dates :</p>ANY TIME<br />
											
						<p class="large b mb5px dif">Terms &amp; Conditions :</p>~^#^~~^#^~Package valid only for Indian nationals.
Non-refundable booking fee of Rs.2000 required to confirm/ hold the booking.
Air tickets and hotels are subject to availability. It is mandatory for guests to present valid photo identification at the time of check-in.
The identification proofs accepted are Driving License, Voters Card, Passport, Ration Card. Without valid ID the guest will not be allowed to check in. Note-PAN Cards will not be accepted as a valid ID card.
All transfers and sightseeing are as per the Itinerary/package and in case of Air Conditioned vehicles, It will be switched off in the hills.
The inclusion of extra bed with a booking is facilitated with a folding cot or a mattress as an extra bed. Early check-in or late check-out is subject to availability and may be chargeable by the hotel. The standard check-in time is 1300hrs and the standard check-out time is 1000hrs.
Any kind of personal expenses (Laundry, room service etc..) or optional tours/ extra meals are not inclusive in the package cost.
The hotel reserves the right of admission. Accommodation can be denied to guests posing as a couple if suitable proof of identification is not presented at check-in. Arihant tours will not be responsible for any check-in denied by the hotel due to the aforesaid reason.
In case of non-availability of above mentioned hotels similar category hotel will be provided.
Arihant Tours reserves the right to change/modify or terminate the offer any time at its own discretion and without any prior notice.						
    	<p class="h dif xlarge b mb5px">Package cost</p>
    	<div class="otherDetails aj">EX- COCHIN</div><br>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Package Type</td>
				<td class="headHr p5px b">Rate per Adult</td>
				<td class="headHr p5px b">Extra Person</td>
			</tr>
			<tr>
				<td class="data p5px">Standerd</td>
				<td class="data p5px">17500/-</td>
				<td class="data p5px">12000/-</td>
			</tr>
			<tr>
				<td class="data p5px">Deluxe</td>
				<td class="data p5px">21000/-</td>
				<td class="data p5px">17000/-</td>
			</tr>
			<tr>
				<td class="data p5px">Super Deluxe</td>
				<td class="data p5px">27500/-</td>
				<td class="data p5px">22000/-</td>
			</tr>
		</table></div><br>						</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.arihanttours.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="My Dream 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="25203"/>
						</form>
						</div>
						
						";i:1;s:59:"Book My Dream Kerala Tour - 6 Nights / 7 Days Tour Packages";i:2;s:152:"book my dream kerala tour - 6 nights / 7 days tour packages, forts and palaces tour packages, kumarakom, kochi, thekkady, alleppey, munnar tour packages";i:3;s:182:"Arihant Tours offers My Dream Kerala Tour - 6 Nights / 7 Days tour package, budget Forts and Palaces tour packages for Kumarakom, Kochi, Thekkady, Alleppey, Munnar at exciting price.";i:4;s:1162:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Kumarakom, Kochi, Thekkady, Alleppey, Munnar"        
		                 },
		      "description": "Sandwiched between the tall mountains and deep blue sea, is the South-Western State of Kerala. It is a State, blessed with a long shoreline and serene beaches, emerald backwaters, lushgreen hillstations, aromatic plantations, abundant wildlife, waterfalls, history, culture, monuments, exotic cuisine… No wonder, it is called – ‘God’s Own Country’.Entrance charges anywhere are not included
Expenses of personal nature such as tips, telephone calls, laundry, liquor etc
The package does not include guide services
Air Fare/Train Fare and all entry fees at sightseeing spots
Service Tax 2.58% Extra If Required Bill for claim LTA
The above package is not valid during national holidays, festivals & long weekends",
		      "name": "My Dream Kerala Tour",
		      "telephone": "+91-9420566577"
		    }
		    </script>
			";i:5;N;}