a:6:{i:0;s:18508:"				<div class="h1"><h1>Nainital Corbett MTB Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.rapidactionexpedition.in/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.rapidactionexpedition.in/tour-packages.htm" title="Tour Packages">Tour Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Nainital Corbett MTB Tour</p>
				<br />
				
								
						<script language="javascript"> 
							function topDestinationToggle(showHideDiv, switchTextDiv) {
							var ele = document.getElementById(showHideDiv);
							var text = document.getElementById(switchTextDiv);
							if(ele.style.display == "block") {
								ele.style.display = "none";
							  text.innerHTML = "View More &#9660;";
							}
							else {
							  ele.style.display = "block";
							  text.innerHTML = "View Less &#9650;";
							}
							}
		                </script>
											<script type="text/javascript">			
					(function($){	
					  $(function(){
						$('[id^=detailslider]').each(function(){
							$(this).DG_Slider({
								auto: true, mode:'fade', pager:true, pagerType:'short',controls:true
							});
						})
				
						$('a[rel=gall]').fancybox()
					  });	
					}(jQuery))
					</script>
					
					<br />
					<div class="data">
					<table class="w100 formTable bdr0 imgWidth">
					<tr>
					<td class="p10px">
					<table class="w100 packageForm">
											<tr>
						<td class="b p5px w125px vat">Duration </td>
						<td class="p5px pl0px vat">
						6 Nights / 7 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Nainital, Kathgodam</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.rapidactionexpedition.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Nainital Corbett MTB 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="101011"/>
						</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_15/446641/169648.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/446641/169648.jpg"  width="150" height="150"    alt="Nainital Corbett MTB Tour" title="Nainital Corbett MTB Tour" /></a></p></div></li>
																		<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w150px h150px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_15/446641/169649.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/446641/169649.jpg"  width="150" height="150"    alt="Nainital Corbett MTB Tour" title="Nainital Corbett MTB Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					Get on the wheels: Mountain biking in the Himalayas <br />
Mountain biking as an adventure sport has gained tremendous popularity in India owing to the scenic and rugged landscape of Indian Himalayan regions that provide ample opportunities to ardent bikers to satisfy their adrenaline desire. India boasts of having one of the most amazing mountainous terrains in the world. India is full of rough and craggy terrains, steep ascents and narrow single tracks, the mountain biking trails in India are exciting and challenging to get the adrenaline rushing down through the bodies of mountain bikers.<br />
<br />
Why mountain biking? <br />
Mountain biking in India is not only about satisfying your hunger for challenges but it is also about enjoying the beauty of nature that India has to offer. As you get on with a mountain biking expedition with Trek the Himalayas, be prepared to be awed by the mesmerizing beauty of Snow caped Himalayan peaks, lush green meadows, relaxing rides around mountain lakes, vigorously gushing waterfalls, crystal clear rivers, sparkling streams and aw-inspiring flora and fauna. The trails are designed to take you through alpine villages and thick forests, giving you an insight into the culture and lifestyle of the local people living in that region of India. A moderate level of fitness and a desire to seek out the back roads of rural India is all that you need. To view our recommended fitness training regime, click here >> <br />
<br />
Be ready to experience the majestic Uttarakhand you might otherwise miss. Go Mountain-Biking with us to let the level of adrenaline rush pump up as you live your ultimate dream of paddling through India’s most incredible trails. Trek the Himalayas Mountain Biking Expeditions are for explorers with a keen sense of adventure and a desire to explore the real world far from the confines of city life. <br />
<br />
Mountain biking is an exciting challenge to outdoor adventurers. We will take you on a 7 days road trip loaded with adventure, exploration and challenges which is guaranteed to give you a sense of achievement and an urge to go for more!<br />
<br />
About the trail: Nainital Corbett MTB <br />
The route is specially mapped through the most scenic views and challenging trails of Uttarakhand. Through the level is moderate-challenging, the trail offers ample opportunities to test your endurance levels and will power. Gaining an altitude of maximum 7382 feet, you will cover approx 335kms in 7 days. Starting at the beautiful city of Nainital it moves on to Jageshwar through the Binsar Sanctuary culminating at Jim Corbett National Park. It is just not possible to explain the beauty of the expedition in words! One has to do it to feel it.<br />
<br />
The trail is one of the most demanding ones getting you closer to extreme challenges and of course, the rewards of picturesque views of the mighty Himalayas. You will also encounter a number of road riding experiences that will keep you wanting for more. The trail combines ever changing panoramas of Himalayas on rough terrain and challenging weather conditions. The extremes of the cycle ride trail intensify the aesthetics of landscape, the vibrant culture and beliefs of local communities.<br />
<br />
TTH’s nainital Corbett MTB is rich in experiences and will give you a great insight into the awe inspiring terrain and views, all from the unique vantage point of a bicycle.Any kind of personal expenses.<br />
Food during the transit.<br />
Insurance.<br />
Cycle accessories<br />
Anything not specifically mentioned under the head.<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> Kathgodam to Pangot
								</p>
								<p class="aj">Altitude: 6375 ft.<br />
Distance: 41 kms, 2 hours approx.<br />
Temperature: In summer (March July) 25 °C in the day to 12 °C at night<br />
In winter (December– February) 18 °C in day to 8 °C at night<br />
On arrival at Kathgodam Railway Station at 05:30 am , you will be received by our team and driven to Pangot. We will drive through the scenic city of lakes – Nainital. The vicinity of the route is lined by forests of Oak, Rhododendron, Maple, Deodar and many more Himalayan trees. If you are interested in bird watching, you can spot over 580 species of birds. These forests are known to be home to animals like leopards, yellow-throated Himalayan martens, Himalayan palm civets, ghorals, barking deer and sambhar.<br />
After checking-in the comfortable cottages at Pangot, a casual session of introduction and briefing will follow. You can talk to the biking leader and other support staff and get all your queries answered. Next, you can fix up you bikes and get ready for an exciting 7-day adventure. Our guides will also guide you through a small hike around the forest for a glimpse of the upcoming adventure.<br />
Once you’re back at the cottage, you can retire in your rooms after a supple dinner for an exciting next day.<br />
Please note: No ATMs are available in the camping area; Only Vodafone and Idea network have signal strengths here.</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> Pangot to Kwarab - Warm up day
								</p>
								<p class="aj">Distance: 69 kms, 5 hours approx.<br />
The day begins at with a spread of breakfast. Be ready in your cycling gear and your cycle to leave Pangot. The day is a warm-up day with gradual descents through the trail till Kwarab.<br />
Start your cycling for the day with approx 8.3kms stretch towards Nainital to reach Himalayan Viewpoint (7382 ft). You can enjoy spectacular views of the snow laden Himalayas at this point. Our guides can help you identify some of the peaks of the Himalayas.<br />
Moving on, you will experience steep descent of approx. 7kms till you reach Nainital Mall Road – a road famous for tourists visiting Nainital. After a small break at the mall road, if needed, we continue our ride towards Bhowali through a descending route for almost 12kms. Famous for its fruit orchards, Bhowali offers you scenic vistas and unobstructed views of the Himalayan ranges.<br />
Next comes the longest cycling stretch of the day from Bhowali to Kwarab. But it is fairly easy with steep and gradual descents with flat rides for you to enjoy the views, totaling up to 41kms.<br />
At Kwarab, take rest in the serene campsite on the banks of Kosi River and recharge your body for a challenging day ahead.</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> Kwarab to Jageshwar - Strenuous Day
								</p>
								<p class="aj">Altitude: 6037 ft.<br />
Distance: 50 Kms, 8 hours approx.<br />
After our overnight stay at Kosi river, wake up refreshed and start your day after a healthy breakfast. Before you leave, ensure that you carry your packed lunch for the day, as we will reach the next campsite by late afternoon.<br />
Today, is a challenging day with mostly uphill rides.<br />
We start cycling via the Kwarab - Almora Bypass which is steep and gradual ascent of 9.3kms to reach the Almora zoo. The trail passes through green vistas of farms and villages. Next, the small stretch of 3kms from the zoo takes you to the famous Chitai Temple or the Bell Temple – a shrine of Lord Shiva. The temple is believed to be built in 12th century and is renowned for its collection of brass bells of varied sizes, gifted to the Lord by devotees since its inception.<br />
Moving on, a steep descent of approx. 7 kms proves to be a break for you and leads you to a small village Petshal. From Petshal we ride to Barechhina famous for the two pre-historic painted rock shelters. These caves have paintings of animals and humans painted with fingers in black, red and white colours and engravings of trishul and Swastika. The ride from Petshal – Barechhina is a mix of steep and gradual ascent for 4.4 Kms. The trail now takes you to Panwanaula town through a steep ascent and rewards you with a descent till you reach Aartola. To end the day, we enjoy a gradual descent from Aartola to our campsite at Jageshwar for approx. 3 kms.<br />
At the campsite, you can relax and share your challenges with your team mates. Once reenergized, you can take a guided walk to the famous Jageshwar Temple – one of the 12 Jyotirlings India. The temple city comprises a cluster of 124 large and small stone temples, dating 9th to 13th century AD, with many preserved by the Archaeological Survey of India (ASI).<br />
Retire for the night at Deodar Dense forest in tents.</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> Jageshwar to Binsar - Off-road Day
								</p>
								<p class="aj">Altitude: 6800ft.<br />
Distance: 35 kms, 4.5 hours, off-road biking<br />
Note: Since the route is off-road, from Artola to Dhaulchhina no backup vehicle will be available.<br />
Get ready for the much awaited day for the 7 day cycling trip. Today, you will experience an off-road biking adventure through the deep forests. Our guides will brief you beforehand to make your journey more enjoyable. To start, we cycle from Jageshwar to Aartola – a 3 km uphill ride on the road.<br />
We move to off roads at Aartola till Dhaulchhina, a gradual descent of approx. 11 kms through forests. From Dhaulchhina we ride to Gairar Golu Temple through a gradually ascending trail and flat ride for 15.7 kms. Our campsite for the night at Binsar is just 5 kms from the temple and is an easy descent.<br />
At Binsar, stay in tents and share your experiences of the off-road cycling trips.</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> Binsar to Sauni Binsar Scenic Day
								</p>
								<p class="aj">Altitude: 5600ft.<br />
Distance: 66 kms (6 hours)<br />
This is one of the most scenic days of your cycling trip. We start at the beautiful vistas of Binsar and descend till Kosi via a steep and gradual descent of 15 kms. The next stretch of over 32 kms leading us to Ranikhet will be a bit challenging with mostly gradual and steep ascent. From Ranikhet it is an easy descent till Tarikhet Village from where you are just 3 kms away from the campsite at Sauni Binsar</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> Sauni Binsar to Jim Corbett National Park - Corbett day
								</p>
								<p class="aj">Altitude 1180 ft.<br />
Distance: 74 kms, mostly downhill (5.5 hours)<br />
Today is the last riding day of our expedition. And we have kept the best for the last – a ride through Jim Corbett National Park – a site established to protect the endangered Bengal Tiger.<br />
We start from Sauni Binsar to reach Bhatrojkhan Top via a gradually ascending and descending trail of approx 9kms. Moving on, we ride to Mohan which is mostly a descent of 36 kms. And you can enjoy a flat ride of 29 kms in the lush green forests till you reach the campsite at Corbett.<br />
In the evening, a debriefing session will end with a certificate distribution. You can share your feedback and experience of the ride. You can retire for the night at a jungle resort.</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> Depart from Jim Corbett National Park
								</p>
								<p class="aj">We check out of the resort after breakfast. You may take a train or bus from Ramnagar (15 mins drive) or Kathgodam Railway Station or Haldwani Bus stop (1.5 hours drive). Drop can be arranged at extra cost and prior intimation.<br />
Note Cycle Renting:<br />
We highly recommend you bring your own bicycle (Hybrid/MTS). The expedition fee does not include the bicycle charges. Don’t worry!! If you do not intend to carry your own bicycle you can inform us 20 days prior to the commencement of the trip. We can arrange bike hire for you at a very cost effective rate of Rs 5,000/- (entire trip).</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>
												</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Any kind of personal expenses.</li><li>
Food during the transit.</li><li>
Insurance.</li><li>
Cycle accessories</li><li>
Anything not specifically mentioned under the head.</li></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.rapidactionexpedition.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Nainital Corbett MTB 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="101011"/>
						</form>
						</div>
						
						";i:1;s:64:"Book Nainital Corbett MTB Tour - 6 Nights / 7 Days Tour Packages";i:2;s:121:"book nainital corbett mtb tour - 6 nights / 7 days tour packages, valley tour packages, nainital, kathgodam tour packages";i:3;s:161:"Rapid Action Expedition offers Nainital Corbett MTB Tour - 6 Nights / 7 Days tour package, budget Valley tour packages for Nainital, Kathgodam at exciting price.";i:4;s:3915:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Nainital, Kathgodam"        
		                 },
		      "description": "Get on the wheels: Mountain biking in the Himalayas 
Mountain biking as an adventure sport has gained tremendous popularity in India owing to the scenic and rugged landscape of Indian Himalayan regions that provide ample opportunities to ardent bikers to satisfy their adrenaline desire. India boasts of having one of the most amazing mountainous terrains in the world. India is full of rough and craggy terrains, steep ascents and narrow single tracks, the mountain biking trails in India are exciting and challenging to get the adrenaline rushing down through the bodies of mountain bikers.

Why mountain biking? 
Mountain biking in India is not only about satisfying your hunger for challenges but it is also about enjoying the beauty of nature that India has to offer. As you get on with a mountain biking expedition with Trek the Himalayas, be prepared to be awed by the mesmerizing beauty of Snow caped Himalayan peaks, lush green meadows, relaxing rides around mountain lakes, vigorously gushing waterfalls, crystal clear rivers, sparkling streams and aw-inspiring flora and fauna. The trails are designed to take you through alpine villages and thick forests, giving you an insight into the culture and lifestyle of the local people living in that region of India. A moderate level of fitness and a desire to seek out the back roads of rural India is all that you need. To view our recommended fitness training regime, click here >> 

Be ready to experience the majestic Uttarakhand you might otherwise miss. Go Mountain-Biking with us to let the level of adrenaline rush pump up as you live your ultimate dream of paddling through India’s most incredible trails. Trek the Himalayas Mountain Biking Expeditions are for explorers with a keen sense of adventure and a desire to explore the real world far from the confines of city life. 

Mountain biking is an exciting challenge to outdoor adventurers. We will take you on a 7 days road trip loaded with adventure, exploration and challenges which is guaranteed to give you a sense of achievement and an urge to go for more!

About the trail: Nainital Corbett MTB 
The route is specially mapped through the most scenic views and challenging trails of Uttarakhand. Through the level is moderate-challenging, the trail offers ample opportunities to test your endurance levels and will power. Gaining an altitude of maximum 7382 feet, you will cover approx 335kms in 7 days. Starting at the beautiful city of Nainital it moves on to Jageshwar through the Binsar Sanctuary culminating at Jim Corbett National Park. It is just not possible to explain the beauty of the expedition in words! One has to do it to feel it.

The trail is one of the most demanding ones getting you closer to extreme challenges and of course, the rewards of picturesque views of the mighty Himalayas. You will also encounter a number of road riding experiences that will keep you wanting for more. The trail combines ever changing panoramas of Himalayas on rough terrain and challenging weather conditions. The extremes of the cycle ride trail intensify the aesthetics of landscape, the vibrant culture and beliefs of local communities.

TTH’s nainital Corbett MTB is rich in experiences and will give you a great insight into the awe inspiring terrain and views, all from the unique vantage point of a bicycle.Any kind of personal expenses.
Food during the transit.
Insurance.
Cycle accessories
Anything not specifically mentioned under the head.",
		      "name": "Nainital Corbett MTB Tour",
		      "telephone": "+91-9411191687"
		    }
		    </script>
			";i:5;N;}