a:6:{i:0;s:62164:"				<div class="h1"><h1>Spiti Valley Tour - a Trip to Cold Desert of Himachal</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.himalayannavigators.in/" title="Home">Home</a> 
				
								
				<b class="ffv p2px">&rsaquo;</b>Spiti Valley Tour - a Trip to Cold Desert of Himachal</p>
				<br />
				
								
						<script language="javascript"> 
							function topDestinationToggle(showHideDiv, switchTextDiv) {
							var ele = document.getElementById(showHideDiv);
							var text = document.getElementById(switchTextDiv);
							if(ele.style.display == "block") {
								ele.style.display = "none";
							  text.innerHTML = "View More &#9660;";
							}
							else {
							  ele.style.display = "block";
							  text.innerHTML = "View Less &#9650;";
							}
							}
		                </script>
											<script type="text/javascript">			
					(function($){	
					  $(function(){
						$('[id^=detailslider]').each(function(){
							$(this).DG_Slider({
								auto: true, mode:'fade', pager:true, pagerType:'short',controls:true
							});
						})
				
						$('a[rel=gall]').fancybox()
					  });	
					}(jQuery))
					</script>
					
					<br />
					<div class="data">
					<table class="w100 formTable bdr0 imgWidth">
					<tr>
					<td class="p10px">
					<table class="w100 packageForm">
											<tr>
						<td class="b p5px w125px vat">Tour Code </td>
						<td class="p5px pl0px vat">Spiti Fix Departure</td>
						</tr>
												<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">Manali, Shimla, Kinnaur, Lahaul & Spiti, Somnath</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 18000 Per Person						</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.himalayannavigators.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Spiti Valley Tour - a Trip to Cold Desert of Himachal - 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="124754"/>
						</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_10/292604/287859.jpeg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/287859.jpeg"  width="150" height="84"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></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_10/292604/212298.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/212298.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></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_10/292604/214395.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/214395.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></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_10/292604/212306.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/212306.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></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_10/292604/212299.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/212299.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></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_10/292604/212297.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/212297.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></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_10/292604/212296.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/212296.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></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_10/292604/212295.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/212295.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></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_10/292604/200855.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/200855.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></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_10/292604/200854.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/200854.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></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_10/292604/200853.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/200853.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></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_10/292604/200852.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/200852.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></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_10/292604/200851.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/200851.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></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_10/292604/200850.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/200850.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></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_10/292604/200849.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/200849.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></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_10/292604/200848.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/200848.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></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_10/292604/200847.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/200847.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					ABOUT THE SPITI VALLEY ROAD TRIP<br />
Spiti Valley, with an average height of 12,500 feet above sea level, is a desert mountain which lies nestled between India and Tibet. With clear blue skies, snow-capped mountains piercing up and turquoise green streams as your companions, this 10 day Spiti Valley and Kinnaur round trip on the Hindustan-Tibet highway and the Manali – Kaza highway is by far the most unforgettable drives you’ll take in your life.<br />
	<br />
This road trip starts from Chandigarh and ends in Chandigarh including 8 night hotel accommodation and 8 days beautiful drive through the roads of Kinnaur and Spiti region. The trip take you through the beautiful lush green valleys of Kinnaur and takes you into the brown, golden lands of Spiti along with the visits of Buddhist Monasteries, Temples, passes, lakes and high altitude village. This trip offers everything of Unforgettable Himachal that travelers can explore in a single trip. <br />
<br />
Join us  to experience amazing and less explored places of the beautiful Hill state of India.<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> CHANDIGARH ARRIVAL || OVERNIGHT STAY
								</p>
								<p class="aj">Traveler are requested to reach their hotel in Chandigarh by own.</p>					
									<p><b>Meals : </b> No Meals</p>
								</td>
									<td class="p10px vat imgWidth150 w150px lh0">
									<div class="demo-wrap">
									<ul class="lsn m0px p0px" >
												<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_10/292604/200847.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/200847.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></a></p></div></li>
									</ul>
									</div>
									</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 2:</b> CHANDIGARH – SARAHAN | 270 KM / 7 - 8 Hours.
								</p>
								<p class="aj">After breakfast we will start at 08:30 am from the hotel, enjoy the vistas en route.<br />
About 8-9 Hrs and 270 KMS of beautiful drive from Chandigarh via SHIMLA, KUFFRI, FAGU, NARKANDA and RAMPUR. <br />
Upon arrival in Sarahan visit famous BHIMA KALI TEMPLE.</p>					
									<p><b>Meals : </b> Breakfast & Dinner</p>
								</td>
									<td class="p10px vat imgWidth150 w150px lh0">
									<div class="demo-wrap">
									<ul class="lsn m0px p0px" id="detailslider21">
												<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_10/292604/200848.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/200848.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></a></p></div></li>
												<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_10/292604/212295.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/212295.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></a></p></div></li>
									</ul>
									</div>
									</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 3:</b> SARAHAN – SANGLA - KAPLA  | 125 KM / 6-7 HOURS
								</p>
								<p class="aj">Leave Sarahan exact at 08:00 am after the breakfast to enjoy vistas en route.<br />
Take a diversion from KARCHAM to SANGLA VALLEY. Visit SANGLA MEADOWS, KAMMRU FORT, BEIRNG NAG TEMPLE and TIBETAN WOOD CARVING CENTER. 85 Km drive from Sarahan.<br />
Have your lunch at Sangla and after lunch proceed drive to Kalpa (40 Km from Sangla). Upon arrival visit CHANDIKA DEVI TEMPLE. Enjoy the spectacular view of MT. KAILASH from your hotel.</p>					
									<p><b>Meals : </b> Breakfast & Dinner</p>
								</td>
									<td class="p10px vat imgWidth150 w150px lh0">
									<div class="demo-wrap">
									<ul class="lsn m0px p0px" id="detailslider21">
												<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_10/292604/200849.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/200849.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></a></p></div></li>
												<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_10/292604/212296.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/212296.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></a></p></div></li>
									</ul>
									</div>
									</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 4:</b> KALPA – NAKO – NAKO LAKE – GEYU MUMMY – TABO | 155 Km / 7 - 8 Hours
								</p>
								<p class="aj">Start your day early at 08:00 am and watch the vistas en route over Hindustan Tibet Highway.<br />
Check Out KHAB, Confluence of SPITI AND SATLUJ RIVERS<br />
See the LEO PURYGAL PEAK from Khab Bridg. Have your lunch at NAKO LAKE.<br />
Meet the dreaded MALLING NALLA ahead of Nako<br />
After CHANGO – SUMDO you will enter Spiti Valley.<br />
After Sumdo police registration, drive towards GEYU VILLAGE to visit the 500 YEAR OLD MUMMY. Visit TABO MONASTERY at TABO.<br />
About 7– 8 Hrs drive, depending upon the breaks you take in between</p>					
									<p><b>Meals : </b> Breakfast & Dinner</p>
								</td>
									<td class="p10px vat imgWidth150 w150px lh0">
									<div class="demo-wrap">
									<ul class="lsn m0px p0px" >
												<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_10/292604/200850.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/200850.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></a></p></div></li>
									</ul>
									</div>
									</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 5:</b> TABO – DHANKAR – DHANKAR LAKE - KOMIK – HIKKIM – LANGZA - KAZA | 86 KM / 5-6 HOURS DRIVE
								</p>
								<p class="aj">Start your day at 08:30 and we drive towards DHANKAR VILLAGE. Perched high above the confluence of the SPITI AND PIN RIVER, in a hidden bowl, is the tiny hamlet of Dhankar. Explore the 1200-YEAR-OLD DHANKAR GOMPA.<br />
Climb above the village to visit the stunning turquoise DHANKAR LAKE (1 Hour trek from Dhankar Village) which offers views over the valley and towards the twin peaks of Mane Rang (6593 meters).<br />
After that we drive to some of the highest inhabited regions of the world. THE HIGHEST VILLAGE IN ASIA, KOMIK which literally translates to ‘EYE OF A SNOW COCK’ is situated at a height of 4,513 meters. Then we drive to HIKKIM to visit the HIGHEST POST OFFICE in the world. Later we drive to LANGZA (4400 M), you can walk into the village to visit 1000 YEARS OLD LANG (TEMPLE) which. Enjoy the magnificent vistas all day while driving to Kaza.</p>					
									<p><b>Meals : </b> Breakfast & Dinner</p>
								</td>
									<td class="p10px vat imgWidth150 w150px lh0">
									<div class="demo-wrap">
									<ul class="lsn m0px p0px" id="detailslider21">
												<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_10/292604/200851.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/200851.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></a></p></div></li>
												<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_10/292604/212297.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/212297.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></a></p></div></li>
												<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_10/292604/214395.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/214395.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></a></p></div></li>
									</ul>
									</div>
									</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 6:</b> KAZA – KEY – KIBBER – GETTE – THESHIGANG – KAZA | 60 KM / 5-6 HOURS DRIVE
								</p>
								<p class="aj">Today at 09:00 am we drive to world famous KEY MONASTERY. Monastery provide ultimate photo opportunity with over 1000 years’ worth stories to tell, the KI MONASTERY situated at a height of 3,700 meters was founded by a disciple of the famous Atisha, in the 11th century CE.<br />
After that we will drip up the valley to the picturesque village of KIBBER. Located at a height of 4,205 meters and 18 km from Kaza, this formerly highest, permanently inhabited village in this region.<br />
We drive higher up to the secluded village of GETTE where we absorb stunning aerial views of Kaza and tie a PRAYER FLAG. Later drive to TASHIGANG where road ends.<br />
After completing all the sightseeing of today we drive back to Kaza and VISIT SAKAYA TANGYUD MONASTERY, Market etc.</p>					
									<p><b>Meals : </b> Breakfast & Dinner</p>
								</td>
									<td class="p10px vat imgWidth150 w150px lh0">
									<div class="demo-wrap">
									<ul class="lsn m0px p0px" id="detailslider21">
												<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_10/292604/200852.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/200852.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></a></p></div></li>
												<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_10/292604/212298.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/212298.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></a></p></div></li>
									</ul>
									</div>
									</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 7:</b> KAZA – LOSAR - KUNZUM PASS – CHANDRATAL (MOON LAKE) | 90 Km / 4 - 5 Hours
								</p>
								<p class="aj">Today morning at 09:00 am drive to CHANDRATAL LAKE (4300 meters) through LOSAR VILLAGE and KUNZUM PASS 4600 meters. <br />
Upon arrival check in to your camp and have Lunch. <br />
Later visit to CHANDRATAL LAKE which is just 30 minutes trek away from the camp site, explore the beautiful moon shaped lake and CB range which the minimum altitude of 5800 M to 6700 M). <br />
Return back to your camp for dinner and overnight stay.</p>					
									<p><b>Meals : </b> Breakfast & Dinner</p>
								</td>
									<td class="p10px vat imgWidth150 w150px lh0">
									<div class="demo-wrap">
									<ul class="lsn m0px p0px" >
												<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_10/292604/200853.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/200853.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></a></p></div></li>
									</ul>
									</div>
									</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 8:</b> CHANDRATAL – ROHTANG PASS – MANALI | 128 Km / 7 - 8 Hours
								</p>
								<p class="aj">Head to Manali at 08:00 am via ROHTANG PASS (3950 meters).<br />
Drive through BATTAL, CHATRRU, GRAMPHU towards is the most adventures drive of this trip.</p>					
									<p><b>Meals : </b> Breakfast & Dinner</p>
								</td>
									<td class="p10px vat imgWidth150 w150px lh0">
									<div class="demo-wrap">
									<ul class="lsn m0px p0px" id="detailslider21">
												<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_10/292604/200854.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/200854.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></a></p></div></li>
												<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_10/292604/212299.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/212299.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></a></p></div></li>
									</ul>
									</div>
									</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 9:</b> MANALI – CHANDIGARH | 310 Km / 7 - 8 Hours Approx.
								</p>
								<p class="aj">END OF BEAUTIFUL SPITI VALLEY TRIP. After breakfast get ready to drive back to Chandigarh at 08:30 am. Our vehicle will drop you at railway station or any specific point in Chandigarh by evening.</p>					
									<p><b>Meals : </b> Breakfast</p>
								</td>
									<td class="p10px vat imgWidth150 w150px lh0">
									<div class="demo-wrap">
									<ul class="lsn m0px p0px" id="detailslider21">
												<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_10/292604/200855.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/200855.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></a></p></div></li>
												<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_10/292604/212306.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/212306.jpg"  width="150" height="150"    alt="Spiti Valley Tour - a Trip to Cold Desert of Himachal" title="Spiti Valley Tour - a Trip to Cold Desert of Himachal" /></a></p></div></li>
									</ul>
									</div>
									</td>
								</tr>
								</table>					
								</div>						<br />
												 <p class="headHr p7px b pl10px xlarge">Tour Detail</p>
			             <div class="data p15px aj">
										
						<p class="large b mb5px dif">Inclusions :</p>
						<ul>
															<li>MAP (Room + Breakfast + Lunch/Dinner)</li>
																		<li>Hotel</li>
																		<li>Meals</li>
																		<li>Sightseeing</li>
																		<li>Transport</li>
																		<li>Veg Meals</li>
																<li>Breakfast & Dinner.</li><li>
Accommodation on double and triple occupancy. </li><li>
Pickup from specified Hotel at Chandigarh and drop to Chandigarh Airport.</li>
													</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Any Air fare/Train fare.</li><li>
Any type of transportation excluding the provided sightseeing as per itinerary.</li><li>
Any meals other then specified in above package inclusion.</li><li>
Heater charges in hotel during winter season.</li><li>
Travel Insurance.</li><li>
Monuments entry fees/camera fees/Guide fees/entertainment fees.</li><li>
Expenses of personal nature such as telephone calls, laundry, liquor etc.</li><li>
Any other which is not specified in above package Inclusion.</li><li>
Any cost occurred due to snow fall / landslides or any other natural disasters shall be bear by client themselves.</li></ul><br />
												<p class="large b mb5px dif">Departure Cities with rates :</p>Chandigarh<br /><br />
											
						<p class="large b mb5px dif">Terms &amp; Conditions :</p>* 100% Advance Percentage of total booking amount~^#^~* 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.
* Refund will be made within 15 working days from the date of receipt of the cancellation.~^#^~<p><strong>TOUR BOOKING PROCEDURE </strong><br />
All tour details advertised in our website are operated by Himalayan Navigators, registered with Department of Tourism and Civil Aviation Govt. of Himachal Pradesh under the registration number<strong> -</strong> <strong><u>2-32/2013-MNL-TD-1039.</u></strong><br />
<br />
<strong>ALL TOURS ARE SOLD SUBJECT TO THE FOLLOWING CONDITIONS: </strong>

<p><strong>HOW TO BOOK</strong><br />


<p>To make a booking you must pay the relevant deposit and agree to our terms and conditions. The person making the booking (the 'lead name') must be 18 years old or over and possess the legal capacity and authority to make the booking.<br />
<br />
Whether you book alone or as a group, we will only deal with the lead name in all subsequent correspondence, including changes, amendments and cancellations. The lead name is responsible for ensuring the accuracy of the personal details or any other information supplied in respect of yourself and any other person traveling on the booking and for passing on any information regarding the booking or any changes made in relation thereto, to all persons travelling on such booking, including but not limited to information on schedule changes or copies of booking confirmations.

<p> 

<p><strong>PAYMENT PROCEDURE</strong>

<p>You can make advance payment directly by deposit cash in favor of Himalayan Navigators or if you are an online banking user then you can pay by NEFT or IMPS with ease.

<p>You can also pay by credit card / debit card using our payment get way through our website but kindly note that you will be charged 3% extra on the transaction you made through our payment get way.

<p><strong>PLEASE MAKE SURE THAT YOU ARE CERTAIN ABOUT YOUR TRAVEL DATES AND CHOICE OF PACKAGE MAKING A BOOKING WITH. THIS IS ESPECIALLY IMPORTANT BECAUSE IF THE DATES AND PACKAGE TYPE REQUESTED IS AVAILABLE.</strong>

<p><strong>BOOKING CONFIRMATION </strong><br />
To confirm your registration for a fixed departure, a full 100% advance payment is required. If a partial payment (50%) is processed to register for a confirmed participation for a fixed departure, the pending balance has to be paid at least one month prior to start of the departure. If this pending balance is not processed one month prior to the start of the departure, the Company holds the right to cancel the reservation and offer no refund. No intimation will be provided for the same.

<p>Fixed departures (a group of people who make bookings to join a larger group of people) will operate only if we receive a minimum number of participants. For all fixed departure tours, we need a minimum of six people in each batch and multiples of six. For all fixed departure treks, we need a minimum of 10 people in each batch. This minimum number of participants will be decided by the Company on a case to case basis depending on the type of fixed departure that is offered. If the Company do not receive the minimum number of participants for a fixed departure, the Company has the right to cancel the tour/trek and offer the registered participants a full refund or another option where they can still take the fixed departure but at a revised price. In such a case, only if all participants agree to the revised price, will the tour be operational.

<p>If we accept your booking, we will issue a Confirmation Invoice and Vouchers. A contract will exist between us from the date we issue the Confirmation Invoice or if you book within 7 days of departure the contract will exist when we accept your deposit payment. When you receive the Confirmation Invoice please check the details carefully and inform us immediately if anything is incorrect. Names on travel documents must exactly match those in your passports or in other identity Proof documents.

<p><strong>ACCOUNT DETAILS</strong>

<p>BANK NAME - <strong>STATE BANK OF INDIA</strong>

<p>ACCOUNT TYPE - <strong>CURRENT</strong>

<p>ACCOUNT NO. - <strong>33196257094</strong>

<p>BENEFICIARY NAME - <strong>HIMALAYAN NAVIGATORS</strong>

<p>IFSC CODE - <strong>SBIN0002416</strong>

<p>BRANCH ADDRESS -<strong> DOWNTOWN, D-COMPLEX, THE MALL, MANALI-175131, H.P.</strong>

<p><strong>PLEASE NOTE – </strong>Kindly call us or do mail us advance payment receipt / screen shot of payment made by you in favor of Himalayan Navigators and indicating your desired dates of travel—we cannot make a booking without specific dates. Once we confirm the payment made by you then after we will reserve booking in hotels / cabs / buses / other services and send you our tour booking voucher, hotel voucher and other necessary documents. 

<p><strong>YOU ARE REQUESTED TO KEEP YOUR IDENTITY DOCUMENTS I.E. INDIAN VOTER ID CARD/ADHAAR CARD/DRIVING LICENSE/ANY OTHER WITH YOU WHILE TRAVELING AWAY FROM HOME. </strong>

<p><strong>AMENDMENTS / CANCELLATIONS</strong>

<p>In the event you are given the option to cancel or change a reservation, you will be charged a cancellation or change fee pursuant to the rules and restrictions applicable to the supplier providing the travel related product and/or services you selected.

<p>A minimum cancellation policy period, which may vary depending on the supplier of the travel related product and/or service you selected, may apply to your purchase. If you fail to comply with such minimum cancellation policy period, you will be subject to a charge or penalty of applicable rates, tax recovery charges and service fees. In the event you do not show for the first day (or night, as the case may be) of your reservation and intend to check-in at a subsequent date, you must notify Himalayan Navigators or its affiliates of the change no later than the date of the first day (or night, as the case may be) of the original reservation to prevent cancellation of your reservation. You agree to pay any cancellation or change fees that you may incur. Some suppliers do not allow changes to or cancellations of reservations, in which case you will receive no refund from Himalayan Navigators, its affiliates and/or their respective suppliers.

<p>If the Client is willing to amend or cancel his/her booking because of whatsoever reasons including death, accident, illness, or any other personal reasons including non-payment of the balance payment, the Company is liable to recover Cancellation charges from the Client. All cancellations are to be communicated in written and advance amount is non - refundable, besides the forfeiture of the deposit amount of the tour, a further charge will be levied as follows:-

<p>Himalayan Navigators realizes that most people who cancel their reservations do so out of necessity. Nevertheless, cancellations are costly to administer and involve dedicated staff time and communications costs. Please find below our cancellation fee policy for cancellations:

<table border="1" cellpadding="0" cellspacing="0">
	<tbody>
		<tr>
			<td style="width:282px;height:21px;">
			<p align="center"><strong>INTIMATION PERIOD*</strong>
			</td>
			<td style="width:342px;height:21px;">
			<p align="center"><strong>CANCELLATION FEE**</strong>
			</td>
		</tr>
		<tr>
			<td style="width:282px;height:21px;">
			<p align="center"><strong>61 DAYS OR MORE</strong>
			</td>
			<td style="width:342px;height:21px;">
			<p align="center"><strong>10% OF THE TOTAL INVOICE VALUE</strong>
			</td>
		</tr>
		<tr>
			<td style="width:282px;height:21px;">
			<p align="center"><strong>BETWEEN 60 - 30 DAYS</strong>
			</td>
			<td style="width:342px;height:21px;">
			<p align="center"><strong>40% OF THE TOTAL INVOICE VALUE</strong>
			</td>
		</tr>
		<tr>
			<td style="width:282px;height:21px;">
			<p align="center"><strong>BETWEEN 15 - 29 DAYS</strong>
			</td>
			<td style="width:342px;height:21px;">
			<p align="center"><strong>70% OF THE TOTAL INVOICE VALUE</strong>
			</td>
		</tr>
		<tr>
			<td style="width:282px;height:21px;">
			<p align="center"><strong>BETWEEN 8 - 14 DAYS</strong>
			</td>
			<td style="width:342px;height:21px;">
			<p align="center"><strong>90% OF THE TOTAL INVOICE VALUE</strong>
			</td>
		</tr>
		<tr>
			<td style="width:282px;height:21px;">
			<p align="center"><strong>BETWEEN 0 - 7 DAYS</strong>
			</td>
			<td style="width:342px;height:21px;">
			<p align="center"><strong>100% OF THE TOTAL INVOICE VALUE</strong>
			</td>
		</tr>
	</tbody>
</table>

<p>*Intimation Period means the number of days before the tour is scheduled to start

<p>**Cancellation fee is the amount of money that will be deducted from the total billing amount or Invoice total before offering the refund.

<p>Communication fee also be charged at the time of cancellation. No refund will be initiated if tour booked within 0-14 days of departure. 

<p>Any amendment in the original booking has to be given to us in writing. All changes will be processed only after the receipt of the same by the Company. However, if any of the amendment requests results in cancellation of one or more services, then the Company is liable to recover cancellation charges as indicated above.<br />
If you need to cancel your reservation, please send us a mail at <a href="mailto:himalayannavigators@gmail.com">himalayannavigators@gmail.com</a>  and contact a Himalayan Navigators Customer Service Representative. To receive any refund, if applicable, that may be due will be processed within 35 days after our receipt of your written notice of cancellation.<br />
<br />
Traveler substitutions are considered reservation cancellations and are subject to cancellation fees. Please note that we do not make any refunds for any unused portion of your trip.

<p> 

<p><strong>IMPOTRANT NOTES & GENEREL TERMS TO BE ACCEPTED BY PARTICIPANTS</strong>

<ul style="list-style-type:circle;">
	<li><!--[if--><!--[endif]-->Participants have to reach hotel at Chandigarh on day 01 by own. If any participants skip there stay in Chandigarh then they have to reach at Chandigarh hotel or any other specified place on already given time on day 02 (probably at 08:00 am) to join the group with other participants. If any participant failed to reach at specified place in that group will move further to another destination, no trip refund will be initiated.<!--![endif]--><!--![if--></li>
</ul>

<p><!--[if--><!--[endif]-->< ><!--[if--><!--[endif]-->We reserve the right to terminate the participation of any participant who we find guilty for misbehave with the other participants of the group.  <!--![endif]--><!--![if--><!-- --><!--[if--><!--[endif]-->No guide would be assigned for this trip if; driver will take you the near the places mentioned in the itinerary, from where you have to explore the places by own. Not every sightseeing place in Spiti is accessible by vehicle, for some you have to walk/trek. Keep your itinerary with you during your trip. <!--![endif]--><!--![if--><!-- --><!--[if--><!--[endif]-->You have to follow the instructions given by the driver for how much time you have to take at particular sightseeing point. If possible then visit all the sightseeing together with all the participants for the smooth excursion of sightseeing.   <!--![endif]--><!--![if--><!-- --><!--[if--><!--[endif]-->If any participant leaves the group due to any reason in between the trip, in that case no refund will be initiated for the unused portion of trip. No further arrangements provided from our end. If we make any arrangements for you then extra charges shall be paid directly to third party.<!--![endif]--><!--![if--><!-- --><!--[if--><!--[endif]-->All the participants should be ready to leave to next destination / sightseeing before 09:00 am, exact timing will be intimated to you by driver every night once you leave vehicle for hotel stay. <!--![endif]--><!--![if--><!-- --><!--[if--><!--[endif]-->Only BSNL network works in Spiti Valley and there are no network services in between Lossar to Chandrtal and Chandrtal to Rohtang Pass.<!--![endif]--><!--![if--><!-- --><!--[if--><!--[endif]-->We reserve the right to reschedule the sightseeing to ensure smooth execution of tours.<!--![endif]--><!--![if--><!-- --><!--[if--><!--[endif]-->In case of non-availability of rooms in any of given hotel due to any reason; however Himalayan Navigators will reserve another similar category hotel with to its customer.<!--![endif]--><!--![if--><!-- --><!--[if--><!--[endif]-->Meal Plans: - <strong>EPAI</strong>: Room Only, <strong>CPAI</strong>: Room & Breakfast, <strong>MAPAI</strong>: Room, Breakfast & one major meal (Lunch/Dinner), <strong>APAI</strong>: Room & All Meals.<!--![endif]--><!--![if--><!-- --><!--[if--><!--[endif]-->Standard check in time in hotels would be 12:00 noon / 01:00 pm and check out time would be 10:00 am / 11:00 am. All depends on hotels check in, checkout policy and early mornings check in is subject to room availability only.<!--![endif]--><!--![if--><!-- --><!--[if--><!--[endif]-->Facilities like use of heater at hotel rooms in Himachal Pradesh will be chargeable as per Hotel policies. <!--![endif]--><!--![if--><!-- --><!--[if--><!--[endif]-->Hotel could not be changed once you checked into the hotel. If request for hotel change then charges will applicable according to our policy.<!--![endif]--><!--![if--><!-- --><!--[if--><!--[endif]-->Vehicle provided for transfers and sightseeing is not on disposal basis, but from point to point sightseeing basis as per Itinerary. We will not make any refund for the unused portion of the tour / sightseeing.<!--![endif]--><!--![if--><!-- --><!--[if--><!--[endif]-->AC in cab during hill traveling would not be operated. <!--![endif]--><!--![if--><!-- --><!--[if--><!--[endif]-->Please be careful with your personal belongings.<!--![endif]--><!--![if--><!-- --><!--[if--><!--[endif]-->Cancellation of booking is subject to our policy. <!--![endif]--><!--![if--><!-- --><!--[if--><!--[endif]-->Prepone / Postponement of date will be treated as cancellation and will be subject to availability.<!--![endif]--><!--![if--><!-- --><!--[if--><!--[endif]-->No cancellation & any refund will be made at any cost in case of bad weather or land slide or any destination and which is beyond the control of the agent/hotel.<!--![endif]--><!--![if--><!-- --><!--[if--><!--[endif]-->Entrance fees at any point shall be paid by customer directly.<!--![endif]--><!--![if--><!-- --><!--[if--><!--[endif]-->Standard Hotels / Guest House in Spiti Valley only provide basic amenities like basic small rooms, small seating area, room services etc. They do not have any power options in case of any power cut. Do not expect facilities like city hotel in Spiti Valley.<!--![endif]--><!--![if--><!-- --><!--[if--><!--[endif]-->“Himalayan Navigators “ is registered with Department of Tourism and Civil Aviation Government of Himachal Pradesh, and will not be responsible for any loss or damage to person life or Any kind of issue faced during tour, its compulsory to intimate us during that time of tour only, so that it can be rectified. After the tour is complete, we are not liable for any kind of refund.<!--![endif]--><!--![if--><!--[if--><!--[endif]-->

<p> 

<p> 

<p> 

<p><strong>TERMS & CONDITIONS </strong>

<p>The following terms and conditions (“Terms”) apply to your booking (whether online or otherwise). These Terms together with Tour Itinerary (defined hereinafter) shall constitute the entire agreement (“Agreement”) between HIMALAYAN NAVIGATORS (“Company”) and the Client/Customer (“You”) and shall constitute a legally binding agreement. The Terms in this agreement imposes certain obligations on You in connection with your use of the Services (defined hereinafter). By accepting these Terms and booking the Services, you agree to be bound by these Terms:

<p><strong>1.       DEFINITIONS AND INTERPRETATION:</strong>

<p>Tour(s),Road Trip(s),Trek(s) (“Activities”) including but not limited to customized tours, treks, camping, planning of itinerary, arranging through third party service providers, local transport, equipment, food and beverages and accommodation booking, procuring permits and approvals etc., which may include safaris, expeditions, trekking and hiking, rock climbing, river crossing, boating, yak safaris, engaging in art, culture, cooking, tractor riding, bikes and volunteering activities or similar forms of adventure (“Services”) conducted by the Company either with or without coordinators.

<p>(“Tour Itinerary”) means the tour specific terms and conditions which are incorporated in this Agreement by reference, which shall to the extent of any inconsistency with the terms contained in this Agreement will prevail over this Agreement.

<p>Client, Customer, you, your, him, he, his, her, she or similar pronouns shall mean the individual who is/are named on the booking and also the entire group on whose behalf a booking has been made.

<p>Reference to any gender shall include all genders and reference to singular number shall include reference to plural numbers and vice versa as the context may permit or require.

<p> 

<p><strong>2.       ACKNOWLEDGEMENT, ACCEPTANCE AND ASSUMPTION OF RISK, AND INDEMNITY:</strong>

<p>2.1   Services and/or Activities offered and/or conducted by the Company may involve risks beyond those that may be encountered in a more conventional holiday. You understand that you may be traveling to geographical areas where, amongst other things, the standard of accommodation, transport, safety, hygiene, cleanliness, medical and telecommunication facilities and basic infrastructure like electricity, water, sanitation facilities expected of any traditional tourist destination may or may not be available. You further understand that with respect to the activities You may undertake during the Services and/or Activities offered whether forming part of the Tour Itinerary or otherwise. The Company makes no representations about the safety or quality thereof, or the standard of the independent / third party operator running it. You also understand that the Company is not responsible for your safety in this regard.

<p>2.2   You agree, acknowledge and are aware that the Activities conducted whether in well accessible and/or remote/unstable areas may involve use of multi-mode of transport including but not limited to plane, train, two wheelers or four wheelers, boat, horseback, yaks, mules, other conveyance, or on foot. The Activities may involve inherent dangerous risks of illness, diseases, personal injury, death, psychological trauma, emotional distress, mental suffering or loss and damage of property, which may be caused by reasons such as wild animal attacks, forces of nature, civil unrest, terrorism, your unfamiliarity with such terrains and situations and other causes known or unknown with or without any means of quick evacuation and adequate medical assistance or facilities may or may not be available. You also are aware that the Activities may not be safe depending on your condition as it may involve mountaineering, trekking or traversing treacherous or dangerous terrains, safaris and expeditions, in and outside wildlife parks and/or other remote areas, difficult or dangerous terrains. You recognize that such risks may be present at any time before, during, and after the Tour/Treks/Road Trips/Mountain Biking/Activities. You are further aware that the Company relies on third party service providers for accommodation and transportation services, it is to indicate the drivers, equipment that may be used, camping, hotel accommodations and lodging, restaurant services and other services and therefore, is not and cannot be held liable for any death, personal injury, harassment (sexual or otherwise), property damage or other loss that may occur due to any act or omission. Under all the circumstances mentioned herein-above, you hereby fully assume these risks.

<p>2.3   You agree and acknowledge that you are exposed to Risks including but not limited to Risks of personal injury and death attributable to accidents, Act of God - like landslides, avalanches, cloud bursts, earthquakes, floods, wildlife attacks. The Risks also include riots and civil unrest, terrorist attacks, rape, sexual harassment, robbery, mountain sickness, development of medical complication, and any force majeure events, among others (“Risks”). Accordingly, to the fullest extent permitted by the applicable law, you expressly assume any and all Risks arising from or caused by or connected with or attributable to the Services availed. You acknowledge and agree that you have understood completely and are fully aware of the Risks and You are solely responsible for, (and the Company has no responsibility to you or to any third party for) any risk to your life and properties (including risks of personal injury attributable to such reasons as likely to be involved in any adventures) while using the Services and for the consequences of your actions (including any loss or damage which the Company may suffer) by doing so.

<p>2.4   You hereby agree not to claim the unenforceability of your Release, Indemnification obligation and our Limitation of Liability as contained in this Agreement. You agree that the foregoing obligation shall be binding upon you personally as well as upon your heirs, assigns, executors and administrators, and members of your family, companions or persons claiming under you (including those accompanying you for whom You may have paid the applicable fees to the Company and shall also be binding upon any minors who accompany You.

<p>2.5   You hereby confirm that you accept full responsibility for use of the Services and/or Activities in contravention of laws, rules, regulations, and the Terms, and further undertakes to indemnify the Company, and to make good any loss, damage, interest, conversion, including but not limited to any other financial charges and outgoings, costs, and consequences that the Company may incur or suffer on your account and your acts of omission/commission and/or negligence.

<p>2.6   You agree to defend, indemnify and hold harmless the Company and its subsidiaries, affiliates, officers, agents, employees, advertisers, syndication partners, from and against any third party claim or liability arising from or in any way related to (a) your use of the Services and/or Activities (b) your violation of these Terms of Service; or (c) any other action by You connected with the Services and/or Activities, including in all cases above any liability or expense arising from all claims, losses, damages (actual and consequential), suits, judgments, litigation costs and attorneys' fees.

<p>2.7   You agree that you take full responsibility for procuring and carrying all necessary documents required for domestic as well as international travel. In the event your entry to a region is denied due to non-availability of essential documents such as visa and permits with you, You will not hold the Company responsible for this. You understand and agree that the Company will not provide any refunds in such instances where you may be denied privilege of travel to a destination owing to not possessing relevant permits, visa or other essential document as deemed legally essential.

<p><strong>3.       MISCELLANEOUS:</strong>

<p>3.1   The Company may use pictures and videos of you and activities conducted during the Services and/or Activities to promote its services, without having to seek your permission and without obligation to pay you for any such use. If you do not wish to be featured, you should email to the Company email alias mentioned in Section 4.6 to take-down any such pictures and videos that feature you.

<p>3.2   You confirm and declare that you do not have any medical conditions, disability, mental or physical conditions that affect your ability to travel and undertake and complete the Services and/or Activities. You are further aware that the Company may not be able to address your special or specific dietary requirements if any. You hereby confirm that you are physically and mentally fit for undertaking the Services and/or Activities. You further confirm and agree that the Company is not liable to for your treatment should you fall sick during travel.

<p>3.3   You agree that the Company does not represent or warrant to You that your use of the Services and/or Activities will meet your requirements and expectations, that they will be uninterrupted, timely or free from any deficiencies.

<p>3.4   In availing the Services, You hereby expressly disclaim any rights that you may have under any special laws.

<p>3.5 Trip coordinators may or may not have basic first aid and generic medicines for common conditions encountered during travel. You will have to ensure that You have the right drug and also be informed of their own allergies before accepting and consuming any such medication. The Company will not be held responsible for any issues arising from such consumption.

<p>3.6   You agree that the Company may provide you with notices, including those regarding changes to the Terms, by email, regular mail, or postings on the Services.

<p>3.7   The security of all your belongings remains your sole responsibility throughout the tour/trek/road trip. You agree that the Company will not assume any responsibility for loss of, or damage to, baggage or other possessions.

<p>3.8   Every person below the age of 18 years will need to be accompanied by an adult who is above the age of 18 years. If the person accompanying is not the parent, such person below the age of 18 years will be required to produce parental consent in the required format prior to departure. You confirm that you are compliant with this requirement and will abide by the provisions hereof.

<p>3.9   You acknowledge that the cost of the Services and/or Activities does not include any form of insurance, and that if you so require, you will be required to obtain separate coverage at your own cost.

<p>3.10   There is no verbal or written representation, warranty, prior agreement, or description of Services and/or Activities, other than as expressed herein.

<p><strong>4.       LIMITATION OF LIABILITY</strong>

<p>4.1   You expressly understand and agree that except as stated below, the Company shall not be liable to you for: (A) any direct, indirect, incidental, special, consequential or exemplary damages which may be incurred by you, however caused and under any theory of liability. This shall include, but not be limited to any loss of profit, whether incurred directly or indirectly, any loss of goodwill, or business reputation, cost of procurement of substitute Services or goods or other intangible loss; (B) any loss or damage which may be incurred by you, including but not limited to loss or damage as a result of: (I) any reliance placed by you on the completeness, accuracy or existence of any advertising; (II) Any changes which the Company may make to the Services or for any permanent or temporary cessation in the provision of the Services or any features within the Services; (III) your failure to provide the Company with accurate information. (IV) Robbery

<p>4.2   Any liability the Company may incur for the negligent acts and/or omissions of its suppliers shall be limited to a maximum of the price paid by You.

<p> 4.3 The Terms constitute the whole legal agreement between You and the Company and govern your use of the Services (but excluding any services which the Company may provide to you under a separate written agreement), and completely replace any prior agreements between You and the Company in relation to the Services and/or Activities.

<p>4.4       You agree that if the Company does not exercise or enforce any legal right or remedy which is contained in the Terms (or which the Company has the benefit of under any applicable law), this will not be taken to be a formal waiver of the Company rights and that those rights or remedies will still be available to the Company.  

<p>4.5       If any court of law, having the jurisdiction to decide on this matter, rules that any provision of these Terms is invalid, then that provision will be removed from the Terms without affecting the rest of the Terms. The remaining provisions of the Terms will continue to be valid and enforceable.

<p>4.6       You confirm and state that you have the required legal capacity to enter into this agreement and are capable of performing your obligations and undertakings hereunder.

<p>4.7   The Terms, and your relationship with the Company under the Terms, shall be governed by the laws of India without regard to its conflict of laws provisions.  All reservations (online or otherwise) shall be deemed as booked in Kaza / Shimla / Manali / Dharamshala. You agree to submit to the exclusive jurisdiction of the courts located within the city of Manali to resolve any disputes arising from/in connection with the Terms.

<p>4.8 All product and company names are trademarks™ or registered® trademarks of their respective holders. Use of them does not imply any affiliation with or endorsement by them. All specifications are subject to change without notice.

<p>4.9   By booking the Services and/or Activities with the Company (directly or through any of its agents/authorized representatives), you acknowledge and agree that you have read, understood and agree to be legally bound by these Terms and this Agreement.

<p><!--![endif]--><!--![if--><!--![endif]--><!--![if--><!--![endif]--><!--![if--><!--![endif]--><!--![if--><!--![endif]--><!--![if--><!--![endif]--><!--![if--><!--![endif]--><!--![if--><!--![endif]--><!--![if--><!--![endif]--><!--![if--><!--![endif]--><!--![if--><!--![endif]--><!--![if--><!--![endif]--><!--![if--><!--![endif]--><!--![if--><!--![endif]--><!--![if--><!--![endif]--><!--![if--><!--![endif]--><!--![if--><!--![endif]--><!--![if--><!--![endif]--><!--![if--><!--![endif]--><!--![if--><!--![endif]--><!--![if--><!--![endif]--><!--![if--><!--![endif]--><!--![if-->												</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.himalayannavigators.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Spiti Valley Tour - a Trip to Cold Desert of Himachal - 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="124754"/>
						</form>
						</div>
						
						";i:1;s:92:"Book Spiti Valley Tour - a Trip to Cold Desert of Himachal - 8 Nights / 9 Days Tour Packages";i:2;s:179:"book spiti valley tour - a trip to cold desert of himachal - 8 nights / 9 days tour packages, camping tour packages, manali, shimla, kinnaur, lahaul & spiti, somnath tour packages";i:3;s:216:"Himalayan Navigators offers Spiti Valley Tour - a Trip to Cold Desert of Himachal - 8 Nights / 9 Days tour package, budget Camping tour packages for Manali, Shimla, Kinnaur, Lahaul & Spiti, Somnath at exciting price.";i:4;s:1517:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Manali, Shimla, Kinnaur, Lahaul & Spiti, Somnath"        
		                 },
		      "description": "ABOUT THE SPITI VALLEY ROAD TRIP
Spiti Valley, with an average height of 12,500 feet above sea level, is a desert mountain which lies nestled between India and Tibet. With clear blue skies, snow-capped mountains piercing up and turquoise green streams as your companions, this 10 day Spiti Valley and Kinnaur round trip on the Hindustan-Tibet highway and the Manali – Kaza highway is by far the most unforgettable drives you’ll take in your life.
	
This road trip starts from Chandigarh and ends in Chandigarh including 8 night hotel accommodation and 8 days beautiful drive through the roads of Kinnaur and Spiti region. The trip take you through the beautiful lush green valleys of Kinnaur and takes you into the brown, golden lands of Spiti along with the visits of Buddhist Monasteries, Temples, passes, lakes and high altitude village. This trip offers everything of Unforgettable Himachal that travelers can explore in a single trip. 

Join us  to experience amazing and less explored places of the beautiful Hill state of India.",
		      "name": "Spiti Valley Tour - a Trip to Cold Desert of Himachal",
		      "telephone": "+91-8091208888"
		    }
		    </script>
			";i:5;N;}