a:6:{i:0;s:7290:"				<div class="h1"><h1>Stok Kangri Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.nomadicsteps.co.in/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.nomadicsteps.co.in/packages.htm" title="Packages">Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Stok Kangri 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">
						9 Nights / 10 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Leh Ladakh</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat"><span class="dif">On Request</span></td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.nomadicsteps.co.in/enquiry-form-10003.htm">
						<input type="hidden" name="subject" value="Stok Kangri 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="87839"/>
						</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_16/466826/153241.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_16/466826/153241.jpg"  width="150" height="150"    alt="Stok Kangri Tour" title="Stok Kangri Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					Best Season: Mid June - Mid October<br />
Altitude: 6125 mts.<br />
Total Trekking: 80 K.M<br />
About Stok Kangri<br />
Crossing several obstacles, climbing on the steep slopes, withstanding sunny mornings to blizzard and walking past meandering tracks towards the 6153 meters is what it takes to do the Stok Kangri Trek. That's the challenge trekkers have to accept to reach the paradise within 5-6 challenging days. Being one of the most difficult treks in India, the Stok Kangri Trek is meant for those amateur and experienced trekkers that have one or two trekking experiences above 5000 meters.<br />
<br />
Ladakh brings forth many trekking tours but the Stok Kangri Trek is simply a walk to heaven. If one is lucky enough, he has the opportunity to catch the glimpse of the towering peak of K2 and the view of several crystal crests and large moraines winding down the barren valleys. During the trek get the chance of 360 degree view of the Saser Kangri, which dominates the northern sky on the Karakoram Range and the Zanskar Range on the south.<br />
The Stok Kangri Trek is one of the strenuous treks in the Ladakh region that requires serious acclimatization before hitting the tracks to Rumbak village. Even after crossing several mountain passes like Stok La at 4900 meters, the trail requires acclimatization at the Stok Kangri Base camp after camping and crossing Mankorma. The journey en route and thereafter passes through some narrow tracks and dangerous moraines; one might encounter snowstorms, which may slow down or hold back trekking to Stok Kangri. The Stok Kangri Trek creates a wholesome experience for the trekker. This dream expedition offers camping, facilities for home stay at a remote village, scenic beauty and pleasant stories.<br />
Stok Kangri Trekking Tour Highlights<br />
Visit some of the important monasteries of Ladakh<br />
Get a good look at some of the stunning landscape and hulking high peaks of Zanskar and Karakoram Range<br />
Cross through the gorgeous Markha Valley<br />
Homestay at some scenic remote village and an opportunity to imbibe the lifestyle of the locals.<br />
Best Time to Visit<br />
The best time to visit Stok Kangri Trek is between May and mid-October. During this time, the weather in Ladakh is pleasant and the average temperature ranges between 20 and 30°C in the daytime. July and August are the ideal months for Sham Valley trek as during these months Manali-Leh and Srinagar-Leh highways also opens for private vehicles.<br />
Where is the Stok Kangri?<br />
The magnificent Stok Kangri (6153m) is situated in the south of Leh. Declared an open trekking peak by Indian mountaineering foundations, Stok Kangri can be done by anyone who is physically fit. From the summit stunning views of Karakoram Range, Ladakh Range and Zanskar range can be witnessed. During clear sky K2 can also be seen at far distance.<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>
												</ul>
						<br />
											
						<p class="large b mb5px dif">Terms &amp; Conditions :</p>* Some Advance Percentage of total booking amount 
* Airfare/Transport fare to be paid full at one time in advance.~^#^~* 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. ~^#^~												</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.nomadicsteps.co.in/enquiry-form-10003.htm">
						<input type="hidden" name="subject" value="Stok Kangri 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="87839"/>
						</form>
						</div>
						
						";i:1;s:56:"Book Stok Kangri Tour - 9 Nights / 10 Days Tour Packages";i:2;s:104:"book stok kangri tour - 9 nights / 10 days tour packages, valley tour packages, leh ladakh tour packages";i:3;s:134:"Nomadic Steps offers Stok Kangri Tour - 9 Nights / 10 Days tour package, budget Valley tour packages for Leh Ladakh at exciting price.";i:4;s:3205:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Leh Ladakh"        
		                 },
		      "description": "Best Season: Mid June - Mid October
Altitude: 6125 mts.
Total Trekking: 80 K.M
About Stok Kangri
Crossing several obstacles, climbing on the steep slopes, withstanding sunny mornings to blizzard and walking past meandering tracks towards the 6153 meters is what it takes to do the Stok Kangri Trek. That's the challenge trekkers have to accept to reach the paradise within 5-6 challenging days. Being one of the most difficult treks in India, the Stok Kangri Trek is meant for those amateur and experienced trekkers that have one or two trekking experiences above 5000 meters.

Ladakh brings forth many trekking tours but the Stok Kangri Trek is simply a walk to heaven. If one is lucky enough, he has the opportunity to catch the glimpse of the towering peak of K2 and the view of several crystal crests and large moraines winding down the barren valleys. During the trek get the chance of 360 degree view of the Saser Kangri, which dominates the northern sky on the Karakoram Range and the Zanskar Range on the south.
The Stok Kangri Trek is one of the strenuous treks in the Ladakh region that requires serious acclimatization before hitting the tracks to Rumbak village. Even after crossing several mountain passes like Stok La at 4900 meters, the trail requires acclimatization at the Stok Kangri Base camp after camping and crossing Mankorma. The journey en route and thereafter passes through some narrow tracks and dangerous moraines; one might encounter snowstorms, which may slow down or hold back trekking to Stok Kangri. The Stok Kangri Trek creates a wholesome experience for the trekker. This dream expedition offers camping, facilities for home stay at a remote village, scenic beauty and pleasant stories.
Stok Kangri Trekking Tour Highlights
Visit some of the important monasteries of Ladakh
Get a good look at some of the stunning landscape and hulking high peaks of Zanskar and Karakoram Range
Cross through the gorgeous Markha Valley
Homestay at some scenic remote village and an opportunity to imbibe the lifestyle of the locals.
Best Time to Visit
The best time to visit Stok Kangri Trek is between May and mid-October. During this time, the weather in Ladakh is pleasant and the average temperature ranges between 20 and 30°C in the daytime. July and August are the ideal months for Sham Valley trek as during these months Manali-Leh and Srinagar-Leh highways also opens for private vehicles.
Where is the Stok Kangri?
The magnificent Stok Kangri (6153m) is situated in the south of Leh. Declared an open trekking peak by Indian mountaineering foundations, Stok Kangri can be done by anyone who is physically fit. From the summit stunning views of Karakoram Range, Ladakh Range and Zanskar range can be witnessed. During clear sky K2 can also be seen at far distance.",
		      "name": "Stok Kangri Tour",
		      "telephone": "+91-9469261146"
		    }
		    </script>
			";i:5;N;}