a:6:{i:0;s:34303:"				<div class="h1"><h1>Kerala 8N/9D To Upload Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.saisaharatravels.com/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.saisaharatravels.com/packages.htm" title="Packages">Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Kerala 8N/9D To Upload 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">
						8 Nights / 9 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Kochi</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 27666 Per Person						</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.saisaharatravels.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Kerala 8N/9D To Upload 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="106216"/>
						</form>
						</p>
						</td>
						</tr>
											</table>
					</td>
											<td class="p10px vat imgWidth150 w150px lh0">
						<div class="demo-wrap">
						<ul class="lsn m0px p0px" >
															<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w150px h150px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_10/270877/176382.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/270877/176382.jpg"  width="150" height="150"    alt="Kerala 8N/9D To Upload Tour" title="Kerala 8N/9D To Upload Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					Package Cost Per Person -Inr 27666=  Inr 165999/<br />
<br />
Trip to  - Kerala with Rameshwaram <br />
Departure City -  Cochin<br />
Travel Period - VALID 15/Dec/2017 <br />
Duration -  08 Night & 09 Days<br />
No of People - Min 06 Adult <br />
No of Rooms - 03 Double room  <br />
Transportation -Vehicle on Private Basis<br />
Validity of Quote -Till Availability<br />
<br />
2 Night stay in Hotel in Munnar <br />
1 Night stay in Hotel in Thekkady <br />
1 Night stay in Hotel in Alleppey <br />
1 Night stay in Hotel in Kovalam <br />
1 Night stay in Hotel in Kanyakumari <br />
1 Night stay in Hotel in Rameshwaram <br />
1 Night stay in Hotel in Madurai <br />
Breakfast & Dinner  in Munnar, Thekkady, Alleppey, Kovalam, Kanyakumari & Rameshwaram<br />
<br />
All transfers and sightseeing as per itinerary in an Private Ac Tempo Traveler <br />
All toll taxes, parking fees and driver’s allowances <br />
All applicable hotel taxes <br />
All Government service taxes @ 5% on Land Package onlyAll personal expenses, optional tours and extra meals <br />
Medical and travel insurance <br />
Gala Dinner price is not Included<br />
Anything not mentioned under ‘Inclusions’<br />
Items of personal nature like tips, laundry, telephone, beverages etc <br />
Entrance fee / Local Guide / at any place during the tour <br />
Meals not mentioned in the “Inclusions” section. <br />
Anything not mentioned in the package includes section. <br />
Additional sightseeing or usages of vehicle not mentioned in the itinerary<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 & welcome
								</p>
								<p class="aj">Cochin to Munnar(21/Dec/2017)<br />
Drive from Cochin and reach Munnar by afternoon. On the way visit Cheyyara waterfalls, Valara waterfalls, Attukadu waterfalls, Spice plantations etc.</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 2:</b> Munnar Local Sightseeing(22/Dec/2017
								</p>
								<p class="aj">Sightseeing tour of Nyamakadu Waterfalls, Mattupetty Dam, Rose Garden, Echo Point, Blossom Park, Anaimudy View (South India’s highest peak) and Eravikulam National Park (Rajmala), where one can see rare species of fauna such as the Mountain Goat.After sightseeing return back to the hotel and overnight stay at hotel in Munnar.</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 3:</b> Munnar - Thekkady(23/Dec/2017)
								</p>
								<p class="aj">Drive from Munnar to Thekkady. Sightseeing destinations include Periyar wild life sanctuary where you can see wild elephant, bear, deer, the great Indian tiger and more, mullaperiyar dam (you can watch all these only while doing boating in the Lake)You can watch martial arts, kathakali, elephant ride, elephant bath, tribal dance, musical fountain and can go for ayurveda massages (all are optional activities with separate entrance fees). After sightseeing return back to the hotel and overnight stay at hotel in Thekkady.</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 4:</b> :Thekkady - Alleppey(170 Km/3-4 Hrs)(24/Dec/2017)
								</p>
								<p class="aj">Drive from Cochin to Alleppey. Alappuzha, also known as Alleppey is the sixth largest city in Kerala. Alappuzha is considered to be the oldest planned city in this region and the lighthouse built on the coast of the city is the first of its kind. A city with picturesque canals, backwaters, beaches, and lagoons, it was described as the one of the places known as the "Venice of the East" by Lord Curzon. Hence, it is best known as the "Venetian Capital" of Kerala for the Vast backwaters present here. The Backwaters of Alappuzha are the most popular tourist attraction in Kerala.  Later have sightseeing tour of Ambalapuzzha Shree Krishna Temple  and Alleppey Beach.Overnight stay in Hotel in Alleppey.</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 5:</b> Alleppey-  Kovalam(175 Km/3-4 Hrs)(25/Dec/2017
								</p>
								<p class="aj">After breakfast check out of the hotel and proceed to Kovalam.Enroute visit Padmanabhaswamy Temple & Napier Museum.<br />
At reaching Kovalam check into the hotel.<br />
Kovalam is a beach town by the Arabian Sea in Thiruvananthapuram city, Kerala, India. Kovalam has three beaches (Lighthouse Beach, Hawah Beach and Samudra Beach) separated by rocky outcroppings in its 17 km coastline, the three together form the famous crescent of the Kovalam beach. One could enjoy a leisure stay at the Kovalam beach and enjoy the sunrise and sunset view at the beach. The Kovalam lighthouse happens to be a cherished attraction amongst the travellers.Overnight stay at hotel.</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> Kovalam- Kanyakumari(85 Km/2 Hrs)(26/Dec/2017
								</p>
								<p class="aj">After breakfast check out of the hotel and proceed to Kanyakumari than have sightseeing of the beautiful city of Kanyakumari covering the Swami Vivekanand Memorial Rock, Vattakottai Fort,Thiruvalluvar Statue ,Padmanabhapuram Palace & Gandhi Mandapam . After sightseeing return back to hotel and overnight stay at hotel in Kanyakumari</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> Kanyakumari- Rameshwaram(325 KM/5-6 Hrs)(27/Dec/2017
								</p>
								<p class="aj">After breakfast check out from the hotel and proceed to Rameshwaram.At reaching check into the hotel and later have sightseeing of Rameshwaram including Ramanathaswamy Temple,Agni Theertam, Satchi Hanuman Temple, Floating Stone, andPamban Bridge.After sightseeing return back to hotel and overnight stay in hotel in Rameshwaram.</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 8:</b> Rameshwaram- Madurai(185 KM/3-4 Hrs)(28/Dec/2017)
								</p>
								<p class="aj">After breakfast check out of the hotel and proceed to Madurai.Check into the hotel after some relaxation have visit to Tirumalai Nayak Palace, Meenakshi Temple by Walk & Alagzar Temple.After sightseeing return back to hotel and overnight stay at hotel in Madurai.</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 9:</b> Departure From Madurai(29/Dec/2017
								</p>
								<p class="aj">After breakfast check out from the hotel and proceed to Madurai Airport/Railway Station to catch your flight for onwards journey.</p>
								</td>
								</tr>
								</table>					
								</div>						<br />
												 <p class="headHr p7px b pl10px xlarge">Tour Detail</p>
			             <div class="data p15px aj">
										
						<p class="large b mb5px dif">Inclusions :</p>
						<ul>
															<li>Hotel</li>
																		<li>Sightseeing</li>
															</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>All personal expenses, optional tours and extra meals </li><li>
Medical and travel insurance </li><li>
Gala Dinner price is not Included</li><li>
Anything not mentioned under ‘Inclusions’</li><li>
Items of personal nature like tips, laundry, telephone, beverages etc </li><li>
Entrance fee / Local Guide / at any place during the tour </li><li>
Meals not mentioned in the “Inclusions” section. </li><li>
Anything not mentioned in the package includes section. </li><li>
Additional sightseeing or usages of vehicle not mentioned in the itinerary</li></ul><br />
											
						<p class="large b mb5px dif">Terms &amp; Conditions :</p>~^#^~~^#^~<p><strong>Please Note :</strong>

<ul>
	<li>Early check in would be subject to availability and at sole discretion of hotel</li>
	<li>All booking vouchers and tickets will be provided 3 days before departure</li>
</ul>

<p><strong>Terms &amp; Conditions</strong>

<ul>
	<li>The selected hotel/STAR (*) rating of mentioned hotel is based on reputed websites like `Trip advisor` or hotel`s official website. We suggest to all our clients to check such hotels/websites before confirming the package/hotel. Sai Sahara Tours and Travels will not be held responsible for any deviations on expectations after check in at the hotel. If hotel does not provide services to the expectation of customer, Sai Sahara Tours and Travels shall not be held responsible for the same. We request all our customers to look at the reviews of hotel before booking the package.</li>
	<li>Payment- A Booking with 50% Advance of Total Tour Cost is a pre condition and remaining 50% has to be paid at least 30 days in advance of Scheduled Date of Departure. If the Booking is made in less than 30 Days of Scheduled Date of Departure, the entire amount of tour cost has to be paid at the time of Booking.</li>
	<li>Payment can be made by cash or cheque Drawn/payable at Nashik in the name of &ldquo;SAI SAHARA TOURS AND TRAVELS.&rdquo; Bank details given below for NEFT.</li>
	<li>In case of any payment made on the online link through the Net Banking, credit or debit cards there will be a transaction charge of 2.5% of the total booking amount. In case of American Express Card the charges will be 5%. This amount is completely non-refundable in case of ANY/ALL cancellations, refunds etc. at any given point of time. This payment gateway charges will be deducted from the refund amount unless there is a waiver commitment from Sai Sahara Tours and Travels in writing. We strongly recommend all our customers to take all the details in writing through our official id.</li>
	<li>The airfares and taxes are calculated as on a mentioned date and time and any increase in the taxes or airfares will be borne by the customer.</li>
	<li>Tour Cost Includes: Hotel accommodation, Meal as per the plan, rest all will be charged to traveler directly as on it is required like entry ticket at historical/monuments places, camera charges etc.</li>
	<li>Extra bed in the room will be provided by the Hotel as per their rule.</li>
	<li>Hotels reserve the right to admission. Accommodation can be denied to the guests posing as a couple if suitable identification and a non-local address proof is not presented at check-in. Visitors for our guests are allowed to stay in the hotel only till 8:00 PM or as per hotel rules and regulations time. Any request for early or late meals need to be made with the reception at least a night in advance.</li>
	<li>We request our guests to avoid playing loud music in their rooms as that might disturb the stay of our other guests. Hotels do not allow pets anywhere in the premises.</li>
	<li>Ensuring the safety of the valuables would be the sole responsibility of the guests.</li>
	<li>In case of extension of stay, the guests will have to inform the management 24 hours in advance of their original check out time. Stay extension is subjected to availability.</li>
	<li>Cancellation of the booking is subject to the rules and regulations of the hotel.</li>
	<li>In case Cancellation of Tour on Account of Strike/Unrest/Avalanche/Land Slid/Heavy Rains/Earth Quake/Rasta-Rail Roko, the amount already paid shall be adjusted against subsequent Tour, but shall not be Refunded.</li>
	<li>Universal hotel check-in time is between 1400 hrs-1500 hrs and check- out time is between 1100 hrs-1200 hrs depending upon the property. Early Check-In &amp; Late Check- Out is subject to availability of room, it depends on hotel. Early Check in and late checkout will be at additional cost and subject to availability and complete discretion of the hotel. Hotel may or may not provide early check in or late checkout irrespective of availability. Sai Sahara Tours and Travels will not be responsible for any change in the policy of the hotel at any given time.</li>
	<li>Hotel Services: Sai Sahara Tours and Travels does not guarantee quality of service of the hotel and star rating of the hotel. We only recommend hotels basis their reviews and ratings placed on internet by the customers and our previous customer experience. Once a hotel is booked, the booking can be changed on the basis of cancelation policy of the hotel as well as Sai Sahara Tours and Travels. We strongly recommend our customers to go through reviews and photographs of the hotels before making a booking.</li>
	<li>Id Proof: Guest are carry their own Indian Government approved personal original valid identity proof like Passport, Adhar Card, Driving License etc. It is necessary to present at the reception of the hotel at the time of check in/as per hotel demands as per the Indian Govt. Rules and regulations.</li>
	<li>Sai Sahara tours and travels will be not responsible if you do not present the valid id proof at the time of check in at hotel or demand by hotel staffs.</li>
	<li>Government tax will be as applicable.</li>
	<li>No refund will be granted on cancellation of hotel/package/ ticketing.</li>
	<li>Early check in/ Check out is subject to availability of the rooms.</li>
	<li>Pre reservation is required and full payment for the confirmation of the booking.</li>
	<li>Sai Sahara Tours and travel will not be responsible for any loss or damage to a person (life body) or Property, luggage etc. of the tourist due to an accident, theft or other mishap/unforeseen reasons. Travelers has to take care of his/her belongings their own.</li>
	<li>Generally camera and electronics things are not permitted to the monument/ historical places. Only permission able things are to be carried out inside the same.</li>
	<li>Any type of issue will try to be resolved then and there on the immediate intimation after the completion of the tour it cannot be entertained.</li>
	<li>Tour cost published does not include railway/air fare</li>
	<li>If there is any change, the same shall be communicated to the customer before booking.</li>
	<li>The rates are valid for Indian nationals residing in India only. The lead passenger in whose name the hotel booking is made must travel for hotel to honour the booking. In case the lead passenger does not travel at the last minute, the hotel reserves the right to cancel the booking and no refund shall be made either by the hotel or by Sai Sahara Tours and Travels. We request all passenger to update us on the change of name in case of hotel booking at least 30-45 days in advance for us to look into it. In case of NON refundable booking of any hotel</li>
	<li>The penalty for name change and date change will incur as per the airline and the destination. If there is any additional Airport / Airline taxes charged by the any Airport / Airline at any destination, the customer shall bear the same. Sai Sahara Tours and Travels shall not be liable for the same.</li>
	<li>In the event of natural calamities or unavoidable circumstances, the Tour Manger has discretionary powers to modify the route or cancel the tour.</li>
	<li>The company has full rights to alter, amend, postpone or cancel any of the tour which has been advertised, without assigning any reason whatsoever, under circumstances of cancellation of any tour by the company. The traveler paid money will be refunded without any interest.</li>
	<li>It is our ( management of the Sai Sahara Tour and Travels) sole authority to make changes in the program.</li>
	<li>If the tour participant misbehaves in a manner causing inconvenience or annoyance to other tour participants or causes damage to the property of the company he/she will be asked to leave the tour immediately and the tour escorts have been authorized to do so. There will not be any compensation whatsoever in such case, and the cost will be borne by such tourist.</li>
	<li>The organization is not responsible for: Any death, personal injury, sickness, accident, loss, delay, discomfort, increase in expenses and / or damage or theft. The temporary or permanent loss or damage to baggage or personal effects caused by any reasons. The Company reserves the right to claim any additional amount of money for expenses due the delay in trains, bus, air or any other weather conditions, strikes, war</li>
	<li>The organization reserves the right to publish passengers photograph or group photograph without intimation or permission of the passenger or group for its business.</li>
	<li>There can be an increase in the tour cost in case of hike in diesel or petrol cost.</li>
	<li>The passenger is liable to pay the Service Tax on the tour cost.</li>
	<li>Sai Sahara Tours and Travels advise the appropriate time to apply the visa as per the embassy norms, visa will be send for application after receiving the visa documents. Shall there be any delay in receiving the documents/inappropriate documents or in granting the visa from the embassy, Sai Sahara Tours and Travels will not be liable for the same.</li>
	<li>Issuance of visa is in the sole discretion of embassy, Sai Sahara Tours and Travels. DO NOT hold any guarantee for the same. In case the visa is rejected the cancelation policy will stand as it is. We strongly recommend the customers to plan their trip well in advance to avoid cancelation charges.</li>
	<li>The rates are subject to availability of airfare, accommodation, class of booking on the airline and sightseeing tours at the time of booking. Any price increment in the mentioned things will be borne by the customer.</li>
	<li>All the sightseeing tours and excursions are organized by local companies of various destinations. The timings and days of operation are subject to alteration. Changes, if any, will be informed accordingly.</li>
	<li>Sai Sahara Tours and Travels. reserve the right to use an alternate accommodation or airfare of an equal or higher standard. The same shall be determined basis the reviews and ratings of the hotel placed on the internet.</li>
	<li>Seat-in-coach transfers are on fixed timings (Please report at the meeting point min 15 minutes prior to the pickup time). Sai Sahara Tours and Travels will not be responsible for any delay from the customers end.</li>
	<li>No refunds either in part or in full will be made for any unutilized service.</li>
	<li>Prices are subject to change without prior notice as per the Airline / Hotel policy.</li>
	<li>Bookings once confirmed are subject to cancellation charges which shall be advised at the time of making booking.</li>
	<li>In event of cancellation of the tour package on any grounds, the cancelation policy will apply.</li>
	<li>Flight cancellation charges will depend on Airlines . INR 500/- Per Person will be applicable extra as Sai Sahara Tours and Travels service fee. In case the name provided by the customer to book any ticket / hotel is not as per the passport, the customer will bear the charges for changing the name. We strongly recommend to mail us a scanned copy of passport by email or whats app before booking a ticket / hotel. In case the name provided to us over the phone does not match as per the passport, Sai Sahara Tours and Travels shall not be responsible for any change fee. Please provide us name as per below on mail after seeing your passport:</li>
	<li>Any flight cancellation / rescheduling / departure delay or any changes in flights is purely subject to airlines management discussion . Any charges in airfare increase / decrease / rescheduling is to be borne by the client as Sai Sahara Tours and Travels do not hold any guarantee on same.</li>
	<li>Final handover of Hotel vouchers / Air tickets / Visa etc. will be done only upon receiving full and final payment.</li>
	<li>The above is only a quote and no bookings have been made as yet. All conformations are subject to availability at the time of booking. The Quote has been suggested based on specific hotels. If there is a delay in making booking by the customer and due to this delay time, the suggested hotel is not available, in that case, Sai Sahara Tours and Travels reserves the rights to book alternate hotels of similar / same category. In case the customer has some other choice of hotel of same or higher category of hotel which is more expensive than originally suggested, the difference shall be paid by the customer.</li>
	<li>All our packages are based on Night basis and the last day is for check out which will be as per the hotel policy. Sai Sahara Tours and Travels will not be responsible for any extension of stay in the hotel unless explicitly approved in writing by Sai Sahara Tours and Travels.</li>
	<li>Grant of on Arrival visa depends on sole discretion of Immigration Authority and Sai Sahara Tours and Travels is not responsible for any non grant of Visa to traveler. In case the immigration does not provide Visa on Arrival for any reason, the Cancelation policy of Sai Sahara Tours and Travels will stand as it is.</li>
	<li>Kindly avoid being drunk/over drunk by intake of hard drinks during the flights to avoid any Inconvenience during Visa on Arrival, Immigration and Custom Process.</li>
	<li>Passport copies are mandatory to send at the time of confirming the Booking &amp; passport should be valid for minimum 6 months from the date of departure from destination.</li>
	<li>After confirmation of services, if any one wish to change your travel arrangements in any way, for example your chosen departure date or accommodation, we will do our utmost to make these changes but it may not always be possible. Any request for changes to be made must be in writing from the person who made the booking. All cost incurred due to amendment will be borne by yourself.</li>
	<li>You, or any member of your party, may cancel their travel arrangements at any time. Written notification or an e-mail to that effect from the person who made the booking must be received at our offices. The applicable cancellation charges are as per the published cancellation policy which is: Cancellation charges per person</li>
	<li>All the sightseeing tours and excursions are organized by local companies. The timings and days of operation are subject to alteration. Changes if any will be intimated at the time of booking.</li>
	<li>Sightseeing?s tours are strictly based on weather conditions and also local service providers have rights to cancel the sightseeing tours without prior notice.</li>
	<li>For any situation of natural phenomenon like flight delay / cancellation due to fog / rain, flood in a respective country, Traffic Jams or any such situation where one doesn&#39;t have a control, Sai Sahara Tours and Travels will not be responsible.</li>
</ul>

<p><strong>Payment &amp; Pricing:</strong>

<ul>
	<li>The price of your holiday has been quoted in both USD / SGD / EURO and converted into INR at the time of booking after taking exchange rate from Xe.com + INR 1.00 as remittance charge. Sai Sahara Tours and Travels makes remittance to overseas suppliers as per the payment received from the customer. We request all our customer to make the complete payment in first instance. In case, Part payment is made by the customer at the time of booking and remaining on a some later date, then the USD / SGD / EURO price shall be taken on the date of part / remaining payment made as per Xe.com + INR 1.00.</li>
	<li>The price of the package changes due to currency fluctuations in case of overseas travel ? the higher of the two will be charged at the time of payment. We urge our esteemed customers to make the complete payment at the time of booking to avoid any charges arising out of currency fluctuations.</li>
	<li>In case of part payments, Sai Sahara Tours and Travels reserves all rights to charge the higher value applicable as per the quote, till the time final payment does comes in</li>
	<li>We reserve the right to cancel your booking in case full and final payment is not made at the time of booking and later USD / SGD rate fluctuates . To avoid such situations, please make full and final payment at the time of booking.</li>
</ul>

<p><strong>Payment by Credit Cards:</strong>

<ul>
	<li>Your verbal authorization, given to your Travel Agent, for the use of your credit card indicates your compliance with our booking conditions and confirm your reservation whether or not you have actually signed the appropriate authorization form. In the case where the traveler pays with a third person credit card, a written proof of consent must be provided. Once a credit card has been forwarded to Sai Sahara Tours and Travels to guarantee a reservation, the travel agent becomes responsible for payment and must keep a signed copy of the customer`s authorization on file. In the event that a cardholder refuses to honor a charge due to the absence of signature, the Travel Agent will be held responsible for full payment of the services.</li>
</ul>

<p><strong>Know your Customer:</strong>

<ul>
	<li>As per RBI Guidelines, for any international booking being made, Sai Sahara Tours and Travels will need a copy of passport of all the passengers travelling to the destination</li>
</ul>

<p><strong>Travel Insurance:</strong>

<ul>
	<li>We strongly recommend customers purchase travel insurance that covers the risks associated with travelling to a foreign country such as emergency medical assistance and hospitalization as well as cancellations coverage and lost baggage. Consult with your Travel Agent for the plan best suited to your needs.</li>
	<li>During the period of traveling, any loss or damage caused to the customer, shall be the sole responsibility of the customer only in case the insurance is not done. In case the insurance is done then Insurance company is solely responsible for any such loss. Sai Sahara Tours and Travels shall NOT be responsible for any loss or damage caused to the customer while traveling even if Sai Sahara Tours and Travels has been instrumental in providing insurance to the customer through insurance company.</li>
	<li>Taxes and Service Charges: All tour packages are subject to various charges, such as destination hotel taxes and service charges, port taxes on cruises, local government taxes, handling charges as well as on packages inclusive of an airfare, airport taxes, security fees and departure tax. All such charges, as known at the time of printing, are included/excluded in a Sai Sahara Tours and Travels package price. However, such charges are subject to change and unless a holiday package is fully paid any increase will be paid by the passenger.</li>
	<li>All our packages are based on Night basis and the last day is for check out which will be as per the hotel policy. Sai Sahara Tours and Travels will not be responsible for any extension of stay in the hotel unless explicitly approved in writing by Sai Sahara Tours and Travels.</li>
	<li>Please note that we are not holding any reservation, rates are subject to availability at the time of booking and may change any moment without prior notice.</li>
	<li>In the event of any dispute, the dispute shall be referred to the sole arbitrator to be appointed by Sai Sahara Tours and Travels in Nashik and the matter shall be subjected to the jurisdiction of Nashik Courts only.</li>
	<li>All the tourist has to abide by the rules and regulation of the company.</li>
	<li>Hope the above details are as per your requirements .In case of further clarifications or any question (s) please do contact us.</li>
	<li>Waiting for earliest positive reply !!</li>
	<li>WISH YOU A HAPPY JOURNEY</li>
</ul>						
    	<p class="h dif xlarge b mb5px">Hotels in this package:</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Destination</td>
				<td class="headHr p5px b">No. of Nights</td>
				<td class="headHr p5px b">HOTEL</td>
			</tr>
			<tr>
				<td class="data p5px">MUNNAR</td>
				<td class="data p5px">02</td>
				<td class="data p5px">Bella vista resort/Similar</td>
			</tr>
			<tr>
				<td class="data p5px">THEKKADY</td>
				<td class="data p5px">01</td>
				<td class="data p5px">Season Thekkady /Similar</td>
			</tr>
			<tr>
				<td class="data p5px">ALLEPPEY</td>
				<td class="data p5px">01</td>
				<td class="data p5px">Arcadia Regency/Similar</td>
			</tr>
			<tr>
				<td class="data p5px">KOVALAM</td>
				<td class="data p5px">01</td>
				<td class="data p5px">Hawah Beach Resort/Similar</td>
			</tr>
			<tr>
				<td class="data p5px">KANYAKUMARI</td>
				<td class="data p5px">01</td>
				<td class="data p5px">The Gopinivas Grand/Similar</td>
			</tr>
			<tr>
				<td class="data p5px">RAMESHWARAM</td>
				<td class="data p5px">01</td>
				<td class="data p5px">Hotel SS Grand/Similar</td>
			</tr>
			<tr>
				<td class="data p5px">MADURAI</td>
				<td class="data p5px">01</td>
				<td class="data p5px">Hotel Arasan Sapthagiri/Similar</td>
			</tr>
		</table></div><br>						</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.saisaharatravels.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Kerala 8N/9D To Upload 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="106216"/>
						</form>
						</div>
						
						";i:1;s:66:"Book Kerala 8N/9D To Upload Tour - 8 Nights / 9 Days Tour Packages";i:2;s:115:"book kerala 8n/9d to upload tour - 8 nights / 9 days tour packages, hill station tour packages, kochi tour packages";i:3;s:158:"Sai Sahara Tours & Travels offers Kerala 8N/9D To Upload Tour - 8 Nights / 9 Days tour package, budget Hill Station tour packages for Kochi at exciting price.";i:4;s:1783:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Kochi"        
		                 },
		      "description": "Package Cost Per Person -Inr 27666=  Inr 165999/

Trip to  - Kerala with Rameshwaram 
Departure City -  Cochin
Travel Period - VALID 15/Dec/2017 
Duration -  08 Night & 09 Days
No of People - Min 06 Adult 
No of Rooms - 03 Double room  
Transportation -Vehicle on Private Basis
Validity of Quote -Till Availability

2 Night stay in Hotel in Munnar 
1 Night stay in Hotel in Thekkady 
1 Night stay in Hotel in Alleppey 
1 Night stay in Hotel in Kovalam 
1 Night stay in Hotel in Kanyakumari 
1 Night stay in Hotel in Rameshwaram 
1 Night stay in Hotel in Madurai 
Breakfast & Dinner  in Munnar, Thekkady, Alleppey, Kovalam, Kanyakumari & Rameshwaram

All transfers and sightseeing as per itinerary in an Private Ac Tempo Traveler 
All toll taxes, parking fees and driver’s allowances 
All applicable hotel taxes 
All Government service taxes @ 5% on Land Package onlyAll personal expenses, optional tours and extra meals 
Medical and travel insurance 
Gala Dinner price is not Included
Anything not mentioned under ‘Inclusions’
Items of personal nature like tips, laundry, telephone, beverages etc 
Entrance fee / Local Guide / at any place during the tour 
Meals not mentioned in the “Inclusions” section. 
Anything not mentioned in the package includes section. 
Additional sightseeing or usages of vehicle not mentioned in the itinerary",
		      "name": "Kerala 8N/9D To Upload Tour",
		      "telephone": "+91-9623788906"
		    }
		    </script>
			";i:5;N;}