a:6:{i:0;s:39626:"						<section class="headBg theme2 ">
						<div class="wrap">
						<div class="page-title-inner fo"> 
						<div class="h1"><h1>Kerala Tour</h1></div>
						<p class="breadcrumb ar uu small"><a href="http://www.bellwortt.in/" title="Home">Home</a>
						
													<b class="ffv p2px">&rsaquo;</b><a href="http://www.bellwortt.in/holiday-packages.htm" title="Holiday Packages">Holiday Packages</a>
								
						<b class="ffv p2px">&rsaquo;</b> Kerala Tour</p>
						</div>
						</div>
						</section>
										<section id="middle" class="propDtls">
				<div class="wrap packages" id="bodyFormatNT">
									<div class="fo breadcrumb ar uu small db"><span class="pl15px pr15px db mt5px"><a href="http://www.bellwortt.in/" title="Home">Home</a>
					
											<b class="ffv p2px">&rsaquo;</b><a href="http://www.bellwortt.in/holiday-packages.htm" title="Holiday Packages">Holiday Packages</a>  			
											
					<b class="ffv p2px">&rsaquo;</b>Kerala Tour</span></div> 
									
				<div class="row1 dt columns12"><!--MIDDLE ROW1 STARTS-->
				<div class="col-2 wideColumn ip ls"><!--MIDDLE ROW1 COL-2 STARTS-->				
									<div class="fo">
					<div class="db vat pr slideArrow">				
												<ul class="bxslider11 fx-height lh0" style="margin:0px;padding:0px;">
																	<li class="pr">
										<div>										
										<div class="lh0 pa blur-bg" style="background:url(https://ttw.wlimg.com/package-images/photo-big/dir_18/536386/257456.jpg);"></div>
										<a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_18/536386/257456.jpg">
										<div class="slide-fixImag" style="margin:0 9%;"><img src="https://ttw.wlimg.com/package-images/photo-big/dir_18/536386/257456.jpg"  height=""  width=""    alt="Kerala Tour" title="Kerala Tour"  /></div>
										</a>
										</div>
										</li>
																	</ul>
												<div class="sliderCont-Layer">
					<div class="dt w100">
					<div class="dtc vam"><p class="xxxlarge fw7 lh13em">Kerala Tour</p>
											<p class="mt5px"><span class="fw6">Duration</span> : 
						5 Nights / 6 Days 
						</p>
												<p class="mt5px"><span class="fw6">Destination Covered</span> : Kochi, Thekkady, Alleppey, Munnar</p>
											</div>
					<div class="dtc w200px vam"></div>
					</div>
					</div>
					<div class="slidePrice ac">
					<p class="xxlarge red mb12px">
											<span class="xxxlarge fw7"><i class="fa fa-inr"></i> 20000</span>
						<span class="db ttu xsmall mt5px">Per Person</span>
											</p>
											<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.bellwortt.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Kerala Tour - Tour Package"/>
						<input type="hidden" name="allocate_type" value="tour"/>
						<a href="#" onclick="document.getElementById('frmpackagedetail').submit();" class="buttonBig c3px dib p10px15px xlarge fw6">Book Your Tour</a>
						<input type="hidden" name="pkg_slno" value="170614"/>
						</form>
											</div> 
					
					<script>			
					jQuery('.bxslider11').bxSlider({
					  mode:'horizontal',
					  slideWidth:840,
					  auto:true,
					  autoControls:false,
					  stopAutoOnClick:true,
					  pager:false
					});
					</script>
					</div>
					</div>
											<div class="mt7px dif small">* Mentioned prices may vary depending upon date of travel, hotel availability, surge pricing and seasonal rush.</div>
												<div class="mt30px mb30px">
						<div class="b xxlarge mb10px">
								   					<h2>Kochi, Thekkady and Alleppey Tour Overview</h2>
		   											</div>					
						<p class="aj">Surprise Your Beloved with a 5 Nights 6 Days Munnar, Thekkady, Alleppey Honeymoon Package that also Takes You to Kochi. with such An Awesome Amalgamation of Tourist Destinations of Kerala, Your First Love Trip Will Certainly Be a Remarkable One. with this Munnar and Alleppey Honeymoon Package, Which Includes Visits to Thekkady and Kochi, You Will Come Closer to Each other and Your Bond Will Be Strengthened.<br />
<br />
your Munnar, Thekkady, Alleppey Package for Honeymooners Coupled with Kochi Treats You to Pleasurable Sightseeing Attractions and Delightful Activities that Enrich Your Trip. in the Magical Munnar, You Will Visit Mattupetty Dam, Eravikulam National Park, Echo Point, and Tea Museum. When You Move to Thekkady, the Periyar Wildlife Sanctuary Welcomes You and the Jungle Safari Enhances Your Honeymooning Delight. Proceed to Alleppey, Where a Houseboat Stay Awaits Your Visit for a Spellbinding Experience.<br />
<br />
next Destination On Your Munnar Alleppey Thekkady Package from Bangalore is Kochi, Which Offers You Amazing Shopping Options. It is Noteworthy that While Booking a Trip of Your Choice, You Should Carefully Check Kochi, Thekkady, Munnar Itinerary with Alleppey to Be Sure of What the Package Has in Store to Offer You. Choose from a Range of Honeymoon Package to Kerala that are Light On Pockets and Cater to all Your Requirements for An Amazing Honeymoon. No Matter Which One You Select, Be Assured to Smooth Transfers, Comfortable Stay, and Delicious Meals. So, Book a Honeymoon Trip to These Fascinating Destinations of God’s Own Country Today and Gift a Heartening Experience of Togetherness to Your Soul Mate.Air/Train fare<br />
<br />
Early check-in and late checkout<br />
<br />
Boating/ other activities<br />
<br />
Lunch & Dinner<br />
<br />
Anything not mentioned in inclusions</p>
						</div>
														<div class="mt30px b xlarge">
												   					<h2>Kochi, Thekkady and Alleppey Tour Itinerary</h2>
				   													</div>		   
								<br/>
																			<div class="product-desc headVr bdr0 mb12px"> 
											<div class="sub-title p15px"><a href="javascript:void(0)" class="clickable db"><b class="dif mr2px">
																							Day 1											
											:</b> Munnar: Arrival and Quality Leisure Time										
											
											<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a></div>
																							<div class="fo product-detail p15px pt0px">
												Impart a beautiful beginning to the new phase of your life with this Munnar, Thekkady, Alleppey package.<br />
<br />
On your arrival at the Kochi Airport/ Ernakulam Railway Station, enjoy being greeted by an agent’s representative. From here, you will be taken to Munnar to begin your trip amidst the hillscapes. The scenery glams up your journey from Kochi to Munnar. The aroma of spice plantations and symphony of Valara and Cheeyappara waterfalls will add a magical touch to your first trip of togetherness.<br />
<br />
Once you reach Munnar, the pleasant weather, tea plantations, streams, and waterfalls will extend you a hearty welcome. Now, complete the check-in formalities at the hotel, and relax. Rest of the day is at leisure as per this Munnar, Thekkady, Alleppey honeymoon package. Delight in this time as your heart desires. You can explore the surroundings holding hands and enjoy the serene solitude. When the sun sets, come back to the hotel for a restful night.<br />
<br />
Distance from Kochi to Munnar: 130 km (approx.)<br />
<br />
Travel time: 4 hours (approx.)															
														   
											</div> 
											</div>
																						<div class="product-desc headVr bdr0 mb12px"> 
											<div class="sub-title p15px"><a href="javascript:void(0)" class="clickable db"><b class="dif mr2px">
																							Day 2											
											:</b> Munnar: Visit the Tourists Hotspots										
											
											<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a></div>
																							<div class="fo product-detail p15px pt0px">
												The nature’s glamor awaits you as planned by this Kochi, Munnar, Thekkady, Alleppey package for honeymooners.<br />
<br />
Enjoy a scrumptious breakfast together and be prepared to discover the masterpieces with which nature has blessed this quaint hill town. The sightseeing spree takes you to the most sought after attractions of Munnar such as Mattupetty Dam and Lake. The tea garden around mirrors in the crystal clear still water of this dam, enhancing the charm of your visit. Photo Point is another attraction where woods, thick tea plantations, rolling hills, and gurgling rivulets create an ideal environment for love birds, where they have numerous ‘clickable’ moments. You will also be taken to Nursery Garden, Echo Point, and Eravikulam National Park. A view of the beautiful Anaimudi Peak adds to your day.<br />
<br />
In the evening, enjoy a leisurely stroll on the spice/tea trail according to your Munnar, Alleppey honeymoon package with visits to Thekkady and Kochi. This is the best spot to delight in the beautiful sunset with the love of your life. Once you are done with sightseeing, return to the hotel for a refreshing overnight stay.<br />
<br />
Note: Tea Museum remains closed on Mondays.			
														   
											</div> 
											</div>
																						<div class="product-desc headVr bdr0 mb12px"> 
											<div class="sub-title p15px"><a href="javascript:void(0)" class="clickable db"><b class="dif mr2px">
																							Day 3											
											:</b> Thekkady: Arrival and a Memorable Day										
											
											<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a></div>
																							<div class="fo product-detail p15px pt0px">
												This Alleppey, Kochi, Munnar and Thekkady package for honeymoon couples takes you for an unprecedented experience.<br />
<br />
Wake up to a wholesome breakfast and check-out from the hotel. Today, you will be transferred to Thekkady, an astounding location of Periyar National Park near Idukki district. Delighting in the scenery presented by spice plantations, waterfalls, grasslands, and misty mountains, you will reach Thekkady. Now, check-in to the hotel and relax for some time before you will be taken to Periyar Wildlife Sanctuary. The wilderness and a rich variety of flora and fauna will manifold your honeymooning delight. Towards the evening, set off to Kumily village to visit its spice market and also buy some. For a dose of adrenaline, go trekking in Ramakkalmedu, which is among the most beautiful hill stations of Kerala. After a pleasurable day with your sweetheart, return to the hotel and head to your room for a peaceful sleep.<br />
<br />
Optional: Bamboo rafting at Periyar Lake or trekking in Ramakkalmedu (charges extra)<br />
<br />
Distance from Munnar to Thekkady: 94 km (approx.)<br />
<br />
Travel Time: 3 hours (approx.)<br />
<br />
Distance from Thekkady to Ramakkalmedu: 38.8 km (approx.)<br />
<br />
Travel Time: 1 hour (approx.)			
														   
											</div> 
											</div>
																						<div class="product-desc headVr bdr0 mb12px"> 
											<div class="sub-title p15px"><a href="javascript:void(0)" class="clickable db"><b class="dif mr2px">
																							Day 4											
											:</b> Alleppey: Enjoy a Houseboat Experience										
											
											<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a></div>
																							<div class="fo product-detail p15px pt0px">
												An offbeat experience invites you on this day of your Munnar and Alleppey honeymoon package.<br />
<br />
Savor a healthy breakfast before checking out from the hotel. Now, you will be taken to Alleppey, which is among the dreamiest destinations of Kerala. The charismatic surroundings will leave you awestruck. Now, check-in to the houseboat to impart a unique flavor to your honeymoon. Refresh and relish a lavish lunch onboard. Your post lunch time will treat you to a splendid ride as you cruise along Kerala backwaters with your beloved.<br />
<br />
Later, a romantic dinner will enhance the flavor of your day on the houseboat. After adding flavors to your bond, this day will also add some restful moments to your visit as you slip into your comfy bed for the night. Indeed, an unforgettable Alleppey houseboat stay.<br />
<br />
Distance from Munnar to Alleppey: 175.5 km (approx.)<br />
<br />
Travel Time: 4 hours, 30 minutes (approx.)			
														   
											</div> 
											</div>
																						<div class="product-desc headVr bdr0 mb12px"> 
											<div class="sub-title p15px"><a href="javascript:void(0)" class="clickable db"><b class="dif mr2px">
																							Day 5											
											:</b> Kochi: a Short and Exciting Trip										
											
											<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a></div>
																							<div class="fo product-detail p15px pt0px">
												The next leg of your Alleppey, Kochi, Thekkady, Munnar itinerary for honeymoon takes you to Kochi.<br />
<br />
Arise to a lovely breakfast and disembark the houseboat as you will be transferred to Kochi today. Upon arrival in Kochi, check-in to your hotel and unwind for sometime. Now this Kochi tour itinerary takes you for a sightseeing spree. You will be visiting attractions such as St. Francis Church, Mattancherry Palace, the historical town of Fort Cochin, and Marine Drive. You can enjoy a leisurely stroll with your soulmate hand in hand on Marine Drive.<br />
<br />
After a happening day, come back to the hotel for a restful night.<br />
<br />
Distance from Alleppey to Kochi: 53 km (approx.)<br />
<br />
Travel Time: 1 hour, 15 minutes (approx.)			
														   
											</div> 
											</div>
																						<div class="product-desc headVr bdr0 mb12px"> 
											<div class="sub-title p15px"><a href="javascript:void(0)" class="clickable db"><b class="dif mr2px">
																							Day 6											
											:</b> Kochi: Departure Back Home										
											
											<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a></div>
																							<div class="fo product-detail p15px pt0px">
												Your lovely trip concludes in Kochi today<br />
<br />
After breakfast, check-out from the hotel. Get transferred to airport/railway station to board your flight/train for a journey back home.			
														   
											</div> 
											</div>
																			<script>
								jQuery(document).ready(function() {
									//jQuery('.product-detail').css('display','none');
								    jQuery(".sub-title").click(function() {
								        var $this = jQuery(this);
										  jQuery('.w-title').addClass('h15px',400);
								          $this.find('.w-title').removeClass('h15px',400);
										  jQuery('.product-detail').slideUp();
								          $this.next().slideDown();
								          if($this.find('i').hasClass('fa-angle-up')){
								          	$this.find('i').removeClass('fa-angle-up').addClass('fa-angle-down');
								          } else {
								          	$this.find('i').removeClass('fa-angle-down').addClass('fa-angle-up');
								          }
								        });
									});
								</script>
																<div class="data mt20px p15px">
								<div class="mb7px"> 
								<p class="b xlarge mb10px dib">Inclusions</p>
								</div>
												
								<ul>
																			<li>Hotel</li>
																						<li>Meals</li>
																						<li>Sightseeing</li>
																				<li>Breakfast</li><li>
All meals on houseboat</li><li>
Accommodation on twin sharing basis</li><li>
Airport/ Railway Station Transfers</li><li>
Private Cab Transfers</li><li>
GST Honeymoon inclusions (cake, candle light dinner, flower bed decor)</li><li>
Sightseeing tour</li>
																	</ul>
								</div>
																<div class="data mt20px p15px">
								<div class="mb7px"> 
								<p class="b xlarge mb10px dib">Exclusions</p>
								</div>
								
								<ul><li>Air/Train fare</li><li>
Early check-in and late checkout</li><li>
Boating/ other activities</li><li>
Lunch & Dinner</li><li>
Anything not mentioned in inclusions</li></ul>
								</div>
																<div class="data mt20px p15px">            
								<div class="mb7px"> 
								<p class="b xlarge mb10px dib">Payments Terms</p>
								</div>
								
								<ul><li>* Some Advance Percentage of total booking amount 
* Airfare/Transport fare to be paid full at one time in advance.</li></ul>						
								</div>
														<div class="data mt20px p15px">            
						<div class="mb7px"> 
						<p class="b xlarge mb10px dib">Price &amp; Rates</p>
						</div>				
				        <table class="mb15px bdrall bdreee w100 p5px15px formTable">
			            	<tr class="headVr b">
			                	<td class="p5px10px">No of pax</td>
			                    <td class="p5px10px">Age Limit</td>
			                    <td class="p5px10px">Price per pax (Rs)</td>
			                </tr>

															<tr>
				            	<td class="p5px10px">Adult</td>
				                <td class="p5px10px">Above 12 years</td>
				                <td class="p5px10px">
			                				                		<b class="webrupee">INR</b>
			                					                	<b>20000</b> <small>/
			
			                		Adult			
			                				
			                		
			                	</small></td>
				            	</tr>
				            					         </table>
						</div>
					 							<div class="data mt20px p15px">            
						<div class="mb7px"> 
						<p class="b xlarge mb10px dib">Cancellation &amp; Refund Policy</p>
						</div>
						
						<ul><li>* 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.</li></ul>						
						</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.bellwortt.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="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="170614"/>
						</form>
						</div>
						
										</div>
									<div class="col-3 thinColumn"><!--MIDDLE ROW1 COL-1 STARTS-->
					<div class="column_Box mc">
					<div class="tcl bullet divider">
					<div class="h h2"><b class="plusMinus"></b>
					<p class="b dif rHead">Packages by Destination</p>
					</div>
					<div class="ic showHide_rp">
					<div class="mt10px">
											<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="http://www.bellwortt.in/packages-in-deurali.htm" title="Packages in Deurali">Deurali Tours</a> <!--b class="alpha50 bn small">(4)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="http://www.bellwortt.in/packages-in-kathmandu.htm" title="Packages in Kathmandu">Kathmandu Tours</a> <!--b class="alpha50 bn small">(4)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="http://www.bellwortt.in/packages-in-pokhara.htm" title="Packages in Pokhara">Pokhara Tours</a> <!--b class="alpha50 bn small">(4)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="http://www.bellwortt.in/packages-in-ghorepani.htm" title="Packages in Ghorepani">Ghorepani Tours</a> <!--b class="alpha50 bn small">(4)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="http://www.bellwortt.in/packages-in-jaipur.htm" title="Packages in Jaipur">Jaipur Tours</a> <!--b class="alpha50 bn small">(2)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="http://www.bellwortt.in/packages-in-thekkady.htm" title="Packages in Thekkady">Thekkady Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="http://www.bellwortt.in/packages-in-kandy.htm" title="Packages in Kandy">Kandy Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="http://www.bellwortt.in/packages-in-shimla.htm" title="Packages in Shimla">Shimla Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="http://www.bellwortt.in/packages-in-melbourne.htm" title="Packages in Melbourne">Melbourne Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="http://www.bellwortt.in/packages-in-phuket.htm" title="Packages in Phuket">Phuket Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a class="dif" href="http://www.bellwortt.in/packages-in-port-blair.htm" title="Packages in Port Blair">Port Blair Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a class="dif" href="http://www.bellwortt.in/packages-in-bangkok.htm" title="Packages in Bangkok">Bangkok Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a class="dif" href="http://www.bellwortt.in/packages-in-dalhousie.htm" title="Packages in Dalhousie">Dalhousie Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a class="dif" href="http://www.bellwortt.in/packages-in-cairns.htm" title="Packages in Cairns">Cairns Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a class="dif" href="http://www.bellwortt.in/packages-in-udaipur.htm" title="Packages in Udaipur">Udaipur Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a class="dif" href="http://www.bellwortt.in/packages-in-chandigarh-city.htm" title="Packages in Chandigarh City">Chandigarh City Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a class="dif" href="http://www.bellwortt.in/packages-in-kuala-lumpur.htm" title="Packages in Kuala Lumpur">Kuala Lumpur Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a class="dif" href="http://www.bellwortt.in/packages-in-bentota.htm" title="Packages in Bentota">Bentota Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a class="dif" href="http://www.bellwortt.in/packages-in-jaisalmer.htm" title="Packages in Jaisalmer">Jaisalmer Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a class="dif" href="http://www.bellwortt.in/packages-in-munnar.htm" title="Packages in Munnar">Munnar Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a class="dif" href="http://www.bellwortt.in/packages-in-havelock.htm" title="Packages in Havelock">Havelock Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a class="dif" href="http://www.bellwortt.in/packages-in-alleppey.htm" title="Packages in Alleppey">Alleppey Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a class="dif" href="http://www.bellwortt.in/packages-in-nuwara-eliya.htm" title="Packages in Nuwara Eliya">Nuwara Eliya Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a class="dif" href="http://www.bellwortt.in/packages-in-bikaner.htm" title="Packages in Bikaner">Bikaner Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a class="dif" href="http://www.bellwortt.in/packages-in-bali.htm" title="Packages in Bali">Bali Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a class="dif" href="http://www.bellwortt.in/packages-in-corbett.htm" title="Packages in Corbett">Corbett Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a class="dif" href="http://www.bellwortt.in/packages-in-kochi.htm" title="Packages in Kochi">Kochi Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a class="dif" href="http://www.bellwortt.in/packages-in-pattaya.htm" title="Packages in Pattaya">Pattaya Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a class="dif" href="http://www.bellwortt.in/packages-in-manali.htm" title="Packages in Manali">Manali Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a class="dif" href="http://www.bellwortt.in/packages-in-queensland.htm" title="Packages in Queensland">Queensland Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="uu db ar"><a class="showallspan" data-target="show" href="javascript:void(0)" >View More</a></span>
											
					</div>
					</div>
					</div>
					</div>
					
					<div class="column_Box mc">
					<div class="tcl bullet divider">
					<div class="h h2"><b class="plusMinus"></b>
					<p class="b dif rHead">Packages by Theme</p>
					</div>
					<div class="ic showHide_rp">
					<div class="mt10px">
											<span class="dib p5px10px c2px headVr mr7px mb7px "><a href="http://www.bellwortt.in/adventure-holidays-catid.htm" title="Adventure Tour Packages">Adventure Tours</a> <!--b class="alpha50 bn small">(3)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px "><a href="http://www.bellwortt.in/romantic-holidays-catid.htm" title="Romantic Tour Packages">Romantic Tours</a> <!--b class="alpha50 bn small">(3)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px "><a href="http://www.bellwortt.in/river-rafting-holidays-catid.htm" title="River Rafting Tour Packages">River Rafting Tours</a> <!--b class="alpha50 bn small">(2)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px "><a href="http://www.bellwortt.in/trekking-holidays-catid.htm" title="Trekking Tour Packages">Trekking Tours</a> <!--b class="alpha50 bn small">(3)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px "><a href="http://www.bellwortt.in/beach-islands-holidays-catid.htm" title="Beaches and Islands Tour Packages">Beaches and Islands Tours</a> <!--b class="alpha50 bn small">(10)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px "><a href="http://www.bellwortt.in/water-sports-activity-holidays-catid.htm" title="Water Sports Tour Packages">Water Sports Tours</a> <!--b class="alpha50 bn small">(10)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px "><a href="http://www.bellwortt.in/cruise-holidays-catid.htm" title="Ship & Cruise Tour Packages">Ship & Cruise Tours</a> <!--b class="alpha50 bn small">(3)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px "><a href="http://www.bellwortt.in/forts-palaces-holidays-catid.htm" title="Forts and Palaces Tour Packages">Forts and Palaces Tours</a> <!--b class="alpha50 bn small">(3)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px "><a href="http://www.bellwortt.in/heritage-holidays-catid.htm" title="Heritage Tour Packages">Heritage Tours</a> <!--b class="alpha50 bn small">(3)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px "><a href="http://www.bellwortt.in/wildlife-nature-holidays-catid.htm" title="Wildlife Tour Packages">Wildlife Tours</a> <!--b class="alpha50 bn small">(2)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a href="http://www.bellwortt.in/hill-station-holidays-catid.htm" title="Hill Stations & Valleys Tour Packages">Hill Stations & Valleys Tours</a> <!--b class="alpha50 bn small">(5)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a href="http://www.bellwortt.in/religious-pilgrimage-holidays-catid.htm" title="Religious & Pilgrimage Tour Packages">Religious & Pilgrimage Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a href="http://www.bellwortt.in/lakes-rivers-holidays-catid.htm" title="Lakes & Rivers Tour Packages">Lakes & Rivers Tours</a> <!--b class="alpha50 bn small">(2)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a href="http://www.bellwortt.in/national-parks-holidays-catid.htm" title="Wildlife Sanctuaries & National Parks Tour Packages">Wildlife Sanctuaries & National Parks Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a href="http://www.bellwortt.in/safari-holidays-catid.htm" title="Safari Tour Packages">Safari Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a href="http://www.bellwortt.in/golden-triangle-holidays-catid.htm" title="Golden Triangle Tour Packages">Golden Triangle Tours</a> <!--b class="alpha50 bn small">(1)</b--></span>
												<span class="dib p5px10px c2px headVr mr7px mb7px spanlist dn"><a href="http://www.bellwortt.in/mountaineering-holidays-catid.htm" title="Mountaineering Tour Packages">Mountaineering Tours</a> <!--b class="alpha50 bn small">(2)</b--></span>
												<span class="uu db ar"><a class="showallspan" data-target="show" href="javascript:void(0)" >View More</a></span>
							
					</div>
					</div>
					</div>
					</div>
					</div>
									
				
				</div>
				
								<section class="pt20px pb20px absTour-Title rel-prop"><br>
				<div class="wrap">      	
				<div class="myTabs mc bdr0 horizontal987 hot bdr0"><div class=""><ul class="fo lsn m0px p0px"><li class="h hd_h2"><div class="ac"><h2 class="hd_NT">Explore Tour Packages by Destination</h2></div></li></ul></div><p class="cb"></p>
				<div class="ic" id="1102_3-1">
				<div class="slider">
				<ul class="bxslider988">								
				
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="http://www.bellwortt.in/packages-in-deurali.htm" title="Packages in Deurali" ><img src="https://ttw.wlimg.com/package-images/photo-small/dir_18/536386/257487.jpg"  height=""  width=""    alt="Packages in Deurali" title="Packages in Deurali"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="http://www.bellwortt.in/packages-in-deurali.htm" title="Packages in Deurali">Deurali Tours</a></div>
					</div> 
					</li>
					
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="http://www.bellwortt.in/packages-in-kathmandu.htm" title="Packages in Kathmandu" ><img src="https://dynamic.tourtravelworld.com/zsc-header/11246-classified.jpg"  height=""  width=""    alt="Kathmandu" title="Kathmandu"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="http://www.bellwortt.in/packages-in-kathmandu.htm" title="Packages in Kathmandu">Kathmandu Tours</a></div>
					</div> 
					</li>
					
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="http://www.bellwortt.in/packages-in-pokhara.htm" title="Packages in Pokhara" ><img src="https://dynamic.tourtravelworld.com/zsc-header/11247-classified.jpg"  height=""  width=""    alt="Pokhara" title="Pokhara"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="http://www.bellwortt.in/packages-in-pokhara.htm" title="Packages in Pokhara">Pokhara Tours</a></div>
					</div> 
					</li>
					
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="http://www.bellwortt.in/packages-in-ghorepani.htm" title="Packages in Ghorepani" ><img src="https://ttw.wlimg.com/package-images/photo-small/dir_18/536386/257487.jpg"  height=""  width=""    alt="Packages in Ghorepani" title="Packages in Ghorepani"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="http://www.bellwortt.in/packages-in-ghorepani.htm" title="Packages in Ghorepani">Ghorepani Tours</a></div>
					</div> 
					</li>
					
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="http://www.bellwortt.in/packages-in-jaipur.htm" title="Packages in Jaipur" ><img src="https://dynamic.tourtravelworld.com/zsc-header/10096-classified.jpg"  height=""  width=""    alt="Jaipur" title="Jaipur"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="http://www.bellwortt.in/packages-in-jaipur.htm" title="Packages in Jaipur">Jaipur Tours</a></div>
					</div> 
					</li>
					
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="http://www.bellwortt.in/packages-in-thekkady.htm" title="Packages in Thekkady" ><img src="https://ttw.wlimg.com/package-images/photo-small/dir_18/536386/257456.jpg"  height=""  width=""    alt="Packages in Thekkady" title="Packages in Thekkady"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="http://www.bellwortt.in/packages-in-thekkady.htm" title="Packages in Thekkady">Thekkady Tours</a></div>
					</div> 
					</li>
					
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="http://www.bellwortt.in/packages-in-kandy.htm" title="Packages in Kandy" ><img src="https://dynamic.tourtravelworld.com/zsc-header/11334-classified.jpg"  height=""  width=""    alt="Kandy" title="Kandy"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="http://www.bellwortt.in/packages-in-kandy.htm" title="Packages in Kandy">Kandy Tours</a></div>
					</div> 
					</li>
					
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="http://www.bellwortt.in/packages-in-shimla.htm" title="Packages in Shimla" ><img src="https://dynamic.tourtravelworld.com/zsc-header/10070-classified.jpg"  height=""  width=""    alt="Shimla" title="Shimla"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="http://www.bellwortt.in/packages-in-shimla.htm" title="Packages in Shimla">Shimla Tours</a></div>
					</div> 
					</li>
					
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="http://www.bellwortt.in/packages-in-melbourne.htm" title="Packages in Melbourne" ><img src="https://dynamic.tourtravelworld.com/zsc-header/10907-classified.jpg"  height=""  width=""    alt="Melbourne" title="Melbourne"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="http://www.bellwortt.in/packages-in-melbourne.htm" title="Packages in Melbourne">Melbourne Tours</a></div>
					</div> 
					</li>
					
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="http://www.bellwortt.in/packages-in-phuket.htm" title="Packages in Phuket" ><img src="https://dynamic.tourtravelworld.com/zsc-header/11739-classified.jpg"  height=""  width=""    alt="Phuket" title="Phuket"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="http://www.bellwortt.in/packages-in-phuket.htm" title="Packages in Phuket">Phuket Tours</a></div>
					</div> 
					</li>
					
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="http://www.bellwortt.in/packages-in-port-blair.htm" title="Packages in Port Blair" ><img src="https://dynamic.tourtravelworld.com/zsc-header/10155-classified.jpg"  height=""  width=""    alt="Port Blair" title="Port Blair"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="http://www.bellwortt.in/packages-in-port-blair.htm" title="Packages in Port Blair">Port Blair Tours</a></div>
					</div> 
					</li>
					
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="http://www.bellwortt.in/packages-in-bangkok.htm" title="Packages in Bangkok" ><img src="https://ttw.wlimg.com/package-images/photo-small/dir_18/536386/257407.jpg"  height=""  width=""    alt="Packages in Bangkok" title="Packages in Bangkok"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="http://www.bellwortt.in/packages-in-bangkok.htm" title="Packages in Bangkok">Bangkok Tours</a></div>
					</div> 
					</li>
									</ul>
				</div>
				</div>
				 
					<script>
					$(document).ready(function(){			
					$('.bxslider988').bxSlider({
					mode:'horizontal',				
					slideWidth: 214,maxSlides: 10,slideMargin:12,auto: true, 
					autoDirection:'next',
					moveSlides: 1,
					pause:2000,
					pager:false,
					pagerType:'full',
					autoControls: false, 
					controls:true, 
					autoHover:true,				
					speed:1000
					});
					});
					</script>
									
				</div>
				</div><br><br>
				</section>
				
				</div>
				</section>
				
				<script>
					window.addEventListener("DOMContentLoaded", function(){
						jQuery(document).on("click", ".showallspan", function(){
							if(jQuery(this).attr("data-target") === 'show'){
								jQuery(this).text("View Less");
								jQuery(this).attr("data-target", "hide");
								jQuery(this).closest("div").find(".spanlist").removeClass("dn");
							}else{
								jQuery(this).text("View More");
								jQuery(this).attr("data-target", "show");
								jQuery(this).closest("div").find(".spanlist").addClass("dn");
							}
						});
					});
				</script>
				";i:1;s:50:"Book Kerala Tour - 5 Nights / 6 Days Tour Packages";i:2;s:134:"book kerala tour - 5 nights / 6 days tour packages, beaches and islands tour packages, kochi, thekkady, alleppey, munnar tour packages";i:3;s:174:"Bellwortt International offers Kerala Tour - 5 Nights / 6 Days tour package, budget Beaches and Islands tour packages for Kochi, Thekkady, Alleppey, Munnar at exciting price.";i:4;s:2190:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Kochi, Thekkady, Alleppey, Munnar"        
		                 },
		      "description": "Surprise Your Beloved with a 5 Nights 6 Days Munnar, Thekkady, Alleppey Honeymoon Package that also Takes You to Kochi. with such An Awesome Amalgamation of Tourist Destinations of Kerala, Your First Love Trip Will Certainly Be a Remarkable One. with this Munnar and Alleppey Honeymoon Package, Which Includes Visits to Thekkady and Kochi, You Will Come Closer to Each other and Your Bond Will Be Strengthened.

your Munnar, Thekkady, Alleppey Package for Honeymooners Coupled with Kochi Treats You to Pleasurable Sightseeing Attractions and Delightful Activities that Enrich Your Trip. in the Magical Munnar, You Will Visit Mattupetty Dam, Eravikulam National Park, Echo Point, and Tea Museum. When You Move to Thekkady, the Periyar Wildlife Sanctuary Welcomes You and the Jungle Safari Enhances Your Honeymooning Delight. Proceed to Alleppey, Where a Houseboat Stay Awaits Your Visit for a Spellbinding Experience.

next Destination On Your Munnar Alleppey Thekkady Package from Bangalore is Kochi, Which Offers You Amazing Shopping Options. It is Noteworthy that While Booking a Trip of Your Choice, You Should Carefully Check Kochi, Thekkady, Munnar Itinerary with Alleppey to Be Sure of What the Package Has in Store to Offer You. Choose from a Range of Honeymoon Package to Kerala that are Light On Pockets and Cater to all Your Requirements for An Amazing Honeymoon. No Matter Which One You Select, Be Assured to Smooth Transfers, Comfortable Stay, and Delicious Meals. So, Book a Honeymoon Trip to These Fascinating Destinations of God’s Own Country Today and Gift a Heartening Experience of Togetherness to Your Soul Mate.Air/Train fare

Early check-in and late checkout

Boating/ other activities

Lunch & Dinner

Anything not mentioned in inclusions",
		      "name": "Kerala Tour",
		      "telephone": "+91-9599453303"
		    }
		    </script>
			";i:5;N;}