a:6:{i:0;s:45935:"				<div class="h1"><h1>Hill Adventure Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.grihapraveshtravels.in/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.grihapraveshtravels.in/tour-packages.htm" title="Tour Packages">Tour Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Hill Adventure 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">Darjeeling</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 225000 Per Person						</td>
						</tr>
												<tr>
						<td class="b p5px dif w125px vat">Special Offer </td>
						<td class="p5px pl0px dif vat">Paragliding in Darjeeling<br />
Mountain Biking Tours<br />
Rafting in Darjeeling<br />
Camping in Darjeeling<br />
Jeep safari to singalila national park<br />
Rock climbing<br />
Sport climbing<br />
Kayaking</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.grihapraveshtravels.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Hill Adventure 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="111574"/>
						</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/423905/183394.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/423905/183394.jpg"  width="150" height="150"    alt="Paragliding in Darjeeling" title="Paragliding in Darjeeling" /></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/423905/183402.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/423905/183402.jpg"  width="150" height="150"    alt="Traking in Darjeeling" title="Traking in Darjeeling" /></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/423905/183401.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/423905/183401.jpg"  width="150" height="150"    alt="Kayaking" title="Kayaking" /></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/423905/183400.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/423905/183400.jpg"  width="150" height="150"    alt="Sport climbing" title="Sport climbing" /></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/423905/183399.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/423905/183399.jpg"  width="150" height="150"    alt="Rock climbing" title="Rock climbing" /></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/423905/183398.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/423905/183398.jpg"  width="150" height="150"    alt="Jeep safari to singalila national park" title="Jeep safari to singalila national park" /></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/423905/183397.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/423905/183397.jpg"  width="150" height="150"    alt="Camping in Darjeeling" title="Camping in Darjeeling" /></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/423905/183396.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/423905/183396.jpg"  width="150" height="150"    alt="Rafting in Darjeeling" title="Rafting in Darjeeling" /></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/423905/183395.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/423905/183395.jpg"  width="150" height="150"    alt="Mountain Biking Tours" title="Mountain Biking Tours" /></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/423905/183403.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/423905/183403.jpg"  width="150" height="150"    alt="Traking in Sikkim" title="Traking in Sikkim" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					We take pleasure to welcome you to the Official Website of Off Road Adventure!! Off Road Adventure is India Government registered reliable Adventure Company set up by highly knowledgeable tourism professionals with over 10 years of experience in the industry. We are Darjeeling and Sikkim based adventure and trekking company, our office headquarter is located in both Darjeeling and Sikkim state.It has been established as the premier service provider for adventure holidays in India, Nepal and Bhutan. All of our team members are familiar with nature with most having grown up in the Himalayas. Off Road adventure offers activity like Trekking, Mountaineering Expedition, Paragliding, Rafting, Rock Climbing, Camping etc. We are committed in environmental friendly tourism activities and we take pride in doing our part to preserve the natural beauty, respect the way of life of host community, and their local culture and heritage. Our Clients safety, security, comfort and satisfaction are of paramount importance to us. We strive to ensure that each experience with us is fulfilling and memorable.Off Road Adventure was also official adventure partner of "GORKHALAND TERRITORIAL ADMINISTRATION" for 4 years after being the No 1 Adventure and Trekking provider of Darjeeling region. You have known us for years. You have heard or read about our success stories. Some of you have even tried our services and appreciated the quality and the professionalism we deliver. Now, it’s time to get acquainted with the force behind this success, ‘ OUR TEAM ‘.<br />
<br />
Though we come from different field, all of us involved with Off Road Adventure are driven by a common goal, that is; to utilize personal skills, knowledge and experience to deliver the highest level of customer satisfaction through exclusive trekking experience, and promote the tourism industry of the country in every possible way. To make this happen, we provide exceptionally active administration and diligent and smart off-site staffs that are very passionate about the things they do. Together, we come up with innovative ideas to provide some of the most wonderful opportunities to trekkers who are planning their trek in the land on India, Nepal and Bhutan.<br />
<br />
Off Road adventure team is divided into two teams, on-site and off-site team. Each member of the team are handpicked so that they can best utilize their potential to design a wonderful holiday for you. Also, each member whether is be from the on-site team or the off-site team, is considered as an asset of this company. Let’s get introduced to some of the members of our team.Paragliding in Darjeeling<br />
Mountain Biking Tours<br />
Rafting in Darjeeling<br />
Camping in Darjeeling<br />
Jeep safari to singalila national park<br />
Rock climbing<br />
Sport climbing<br />
KayakingOff Road Adventure is a fully licensed and registered adventure and trekking company in India and recognized by the tourism authority of the government of India to run tours, trekking, Peak climbing, mountaineering expeditions and other travel related activities.<br />
<br />
You can book holiday in confidence that your money is protected because we are fully licensed and affiliated with Gorkhaland Territorial administration , Department of Tourism Darjeeling . Lonely Planet . Trip advisor . Himalayan Mountaineering Institute . Indian Mountaineering Foundation .<br />
<br />
Here are copies of all our licenses and authorizations :<br />
<br />
Darjeeling Tourism Department , India<br />
Indian Mountaineering Foundation<br />
Himalayan Mountaineering Foundation<br />
Sikkim Amateur Mountaineering Association<br />
Eastern Himalayan Darjeeling Guide Association<br />
Himachal Paragliding Association<br />
Darjeeling Paragliding Association07-1110-03<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> Darjeeling Paragliding
								</p>
								<p class="aj">Paragliding in Darjeeling<br />
Mountain Biking Tours<br />
Rafting in Darjeeling<br />
Camping in Darjeeling<br />
Jeep safari to singalila national park<br />
Rock climbing<br />
Sport climbing<br />
Kayaking</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_15/423905/183394.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/423905/183394.jpg"  width="150" height="150"    alt="Paragliding in Darjeeling" title="Paragliding in Darjeeling" /></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> Mountain Biking in Darjeeling
								</p>
								<p class="aj">The thrill of mountain biking has to be experienced, to really get the feel of the magnificent landscape and the pure mountain air. Mountain Biking is the best way to see the most exotic sights of the Himalayan region such as ancient trade routes of ancient Trans-Himalayan traders and the mystifying rural life of the hilly towns and villages. In fact biking and hiking make the best adventure options to witness the timeless cultural celebrations and life styles of the hill people as well as the rich bio-diversity of the Himalayan heritage.<br />
Isolated tracks through breathtaking landscape and rugged terrain give the biker a memorable way to experience different cultures and interact with local people sharing their simple lifestyles. Off Road Adventure operates a fleet of top of the line mountain bikes with durable suspensions and high grip tires that can take on any kind of terrain.<br />
<br />
Off Road Adventure only operates Mountain Biking in Darjeeling. The Hilly Terrain of Darjeeling gives you a variety of Biking Options. Whether you would only like to visit surroundings of Darjeeling town and rural areas go for little ‘Off Roading’ rides we have both for you. Our biking trips are well designed and can also be customized according to your needs. Tailor-made travel experiences are our speciality!</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_15/423905/183395.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/423905/183395.jpg"  width="150" height="150"    alt="Mountain Biking Tours" title="Mountain Biking Tours" /></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> Rafting in Darjeeling
								</p>
								<p class="aj">Darjeeling Rafting, With mighty rivers flowing from the majestic mouth of the Himalayas, it is no surprise that Darjeeling and Sikkim is one of the top rafting destinations in India. White water rafting is one of the latest adventure sport in Darjeeling and  Sikkim. Only the Teesta and Rangit rivers offer long stretches which are ideal for safe rafting. Teesta is graded 4 on the International scale. The icy cold waters of the rugged Teesta have a series of rapids with varying intensity and character. It offers one of the finest rafting stretches in the world. Rangit, a tributary of the Teesta, has more turbulent waters and offers many challenges to more experienced rafters.<br />
<br />
The riverbanks of both the rivers have deep forests, with some patches of terraced cultivation, and small villages. Innumerable white sandy beaches offer good campsites. Rapids of classification 2 to 4 are interspersed with placid floats, making rafting an enjoyable experience.<br />
<br />
4500 For Rafting, Full Boat ( 01 Person minimum 07 Person Maximum)<br />
<br />
Distance of Rafting : – 5 to 6 km<br />
<br />
Duration – 30 minutes to 1hr (Depends on Current of water)<br />
<br />
Note : Rafting Transportation from Darjeeling and Back to Darjeeling will Cost Rs 3500/- Darjeeling to Teesta is 1hour Drive.</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_15/423905/183396.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/423905/183396.jpg"  width="150" height="150"    alt="Rafting in Darjeeling" title="Rafting in Darjeeling" /></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> Jeep safari to singalila national park
								</p>
								<p class="aj">Sandakphu Landrover safari ! Are you coming to Darjeeling for vacation?? Staying in Darjeeling surrounded by lots of crowded tourist with lots of pollution and noise, no this is not a vacation we think you wanted. We think vacation for everyone means being closer to mountain, nature and enjoy the cool breeze coming from high mountains with friends and family, enjoying evening dinner with local villagers and get to see the most beautiful views of mountains.<br />
Singalila jeep safari in Darjeeling or better you can call it an off road land rover safari to Sandakphu (3636 meters) the Highest point of West Bengal can be done, Sandakphu which lies in singalila national park is the highest point of West Bengal, situated at the height of 3636 meters gives you the best panoramic view of Nepal and Sikkim Himalayas. Peaks like Everest, Makalu, Kanchenjunga, Lhotse can be seen for sandakphu and phalut. This trip is a totally off road driving, giving your ride inside the national park, One can even get lucky sometimes to see animals like Red panda, Black bears etc on the way.<br />
Any age of tourist can go to Singalila jeep safari as no physical fitness is needed, The trip, which is perfect for those who are on vacation with friends and family. This trip gives you a true meaning of vacation where you will get an adventure, will be closer to nature and mountains, the panoramic and close mountain view which you cannot get from any place of Darjeeling and Sikkim. We Highly Recommend you to visit singalila national park and stay less in town areas of Darjeeling and Sikkim and enjoy a lifetime vacation.</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_15/423905/183398.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/423905/183398.jpg"  width="150" height="150"    alt="Jeep safari to singalila national park" title="Jeep safari to singalila national park" /></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> Rock climbing
								</p>
								<p class="aj">Rock climbing in Darjeeling is another challenging outdoor sport for those who love and live adventure. Rock climbing is an activity in which you will climb up or across natural rock formations with the goal of reaching the summit of a formation or the endpoint of a pre-defined route.<br />
Rock climbing is generally differentiated by its need for the use of the climber’s hands to hold his or her own weight in order to make balance. Rock climbing is a physically and mentally demanding sport, one that often tests a climber’s strength, endurance, agility, and balance along with his or her mental control.<br />
Tenzing Rock, the only natural rock climbing site available in Darjeeling has varied climbing routes with diverse features that caters to different levels of climbers and their calibre. Starting From 20 ft to 80 ft. Off road adventure operates all their rock climbing programs at Tenzing Rock which is approx 5 kms away from main Darjeeling Town. Off Road Adventure, the only Adventure Company in India with Professional Rock Climbing Team participate every year in Various zonal ,national and international Climbing Competitions, Some are even National Champions of India and have represented India in Various International Championships. Sangay Sherpa, a national Level climber himself, with all his expertise and experience supervises the Rock Climbing Section of Off Road Adventure.</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_15/423905/183399.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/423905/183399.jpg"  width="150" height="150"    alt="Rock climbing" title="Rock climbing" /></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> Sport climbing
								</p>
								<p class="aj">Sport Climbing (Wall climbing) is one of the Increasing popular sports in India. It is the popular form of rock climbing. Wall climbing is mostly considered as an indoor sport, but there are also some climbing institutes where it is done outdoor. It resembles rock climbing. The only difference between rock climbing and wall climbing is that the rock climbing is natural whereas wall climbing is artificial.<br />
Darjeeling provides one of the most advance sport climbing wall in India, Various Climbing Competitions are being held here. There is No issue of weather too as Darjeeling provides Indoor and Outdoor Artificial Climbing wall making climbing available for all season. As Sport Climbing is a climbing in Artificial wall, Climbing Routes can be changed depending on your climbing ability, So No worry if You are Professional climber or first timer we will put you on climbing of your level. During Your Climbing session Off Road Adventure will Provide you all Climbing Equipments with professional Rock Climbing Instructors, Most Are Top Climbers of India.</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_15/423905/183400.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/423905/183400.jpg"  width="150" height="150"    alt="Sport climbing" title="Sport climbing" /></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> Kayaking
								</p>
								<p class="aj">A kayak, as we know, is a narrow canoe or a boat propelled by paddles, generally, by one person. Here in Darjeeling, for kayaking, the water sports team of Off Road Adventure will be taken downhill to River Singla approx. 230m (25kms from Darjeeling) above the sea level, meandering between Sikkim and India. Undoubtedly this drop of around 1800 m is sure to be rewarded with more fun and warmth. This sport will last the whole day initiated by a brief session wherein the paddlers will be given instructions as per their activity. Soon after that, under vigilant supervision, the amateurs will be on their own exploring the marine and scenic beauty as per their taste and interest. When fun and learning come together what can be more wonderful.<br />
Chota Rangeet river which flows near Singla is Perfect for Beginners Those Who want To Learn Kayaking, This Place is Also Hot spot for Family, Groups and Adventure Lovers those Who Like to Go For Camping, Kayaking and Do Other Adventure in One Place. One Can also Visit Sikkim which is approx 1km from singla after staying Overnight in Singla.</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_15/423905/183401.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/423905/183401.jpg"  width="150" height="150"    alt="Kayaking" title="Kayaking" /></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> Trekking in Darjeeling
								</p>
								<p class="aj">Trekking in Darjeeling is one of the most preferred activities in Darjeeling for nature lovers. Hilly terrains of Darjeeling region is Internationally acclaimed as a veritable paradise for trekkers and adventure seekers.Hiking or trekking in Darjeeling is the best possible way to experience the local flavors of the destination. With the pace under your command, stop at leisure, meet people who live around there, try native cuisine from small hole-in-the-wall shops, make new friends and come back with an interesting tale of your own. Darjeeling has now become an apt destination for adventure activities like trekking and hiking. Trekking in Darjeeling region is an experience which no lover of nature should miss, It brings one face to face with the sublime grandeur of the Himalayas. The region abounds in rhododendrons, magnolias, premolars, orchids and ferns of numerous varieties. About six hundred different species of birds inhabit the emerald green forest on the slopes of the mountains. High altitude Darjeeling Trekking gives one of the best panorama View of various Peaks Like Everest, Makalu, Kanchenjunga etc. Off Road Adventure offers various options of Trekking in Darjeeling, Sandakphu trek and Singalila ridge trek in Darjeeling is one of the most preferred  trekking routes in Darjeeling.The sheer variety of culture, terrain and trekking trails mean that whether you’re trekking in Darjeeling for the first time or you’ve been before, the experience is always unique.</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_15/423905/183402.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/423905/183402.jpg"  width="150" height="150"    alt="Traking in Darjeeling" title="Traking in Darjeeling" /></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 10:</b> TREKKING IN SIKKIM
								</p>
								<p class="aj">Trekking in Sikkim, Sikkim An abode of snow-capped mountains, tranquil alpine lakes, snow-white glaciers, emerald green meadows, gushing waterfalls and burbling rivers; Sikkim is undoubtedly, a paradise for nature lovers and adventure fanatics. Tremendous scenic beauty and serene ambience of Sikkim fills every visitor’s heart with freshness and rejuvenation.The most ideal way to explore the gorgeous landscape of this quaint little North-Eastern state of India is through trekking in Sikkim. Dotted with enchanting scenic trails that run amidst rich flavours of bio-diversity and splendid culture, a trekking expedition in Sikkim is truly and eye opener and provides the most enriching experience of your lifetime. Whether you are a novice or an expert trekker, with an uncountable number of trekking options of varying difficulty grades, you will never be disappointed in Sikkim.<br />
<br />
To the adventure lovers trekking in Sikkim is an experience of many dimensions. For sheer Exhilaration nothing can match the view of the mountains, which seem to reach the heaven. As you wander up lush green trails you begin to amaze and wonder at the unspoilt natural splendor and dramatic terrain. You may chance upon the shy Musk Deer or wave out to the exotic Red Panda perched among the treetops. Revel in the excitement of being part of a unique culture, a rich tapestry woven with legends, myths, rituals and festivals.<br />
<br />
The ideal time for trekking in Sikkim is during the summer months between March – June and in autumn from mid-September to November. Trekking in monsoons is highly not recommended as most of the roads get blocked due to torrential rains and also, the chances of landslides and cloud bursts are quite high during rainy months. During winters, heavy snow engulfs almost all the higher altitudes making it impossible to trek.</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_15/423905/183403.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/423905/183403.jpg"  width="150" height="150"    alt="Traking in Sikkim" title="Traking in Sikkim" /></a></p></div></li>
									</ul>
									</div>
									</td>
								</tr>
								</table>					
								</div>						<br />
													<div class="headHr">
				            <p class="p7px b pl10px xlarge">Hotel Detail : </p>
				            </div>
															<div class="data lh13em p20px aj mb7px">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px"><p class="fr lh0">
								
																	<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_on.png" alt=""/>
																		<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_on.png" alt=""/>
																		<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_off.png" alt=""/>
																		<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_off.png" alt=""/>
																		<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_off.png" alt=""/>
																		<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_off.png" alt=""/>
																		<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_off.png" alt=""/>
																	
								</p>
								<div class="mb5px">
								<h2 class="dif b xxlarge">Snowlion Homestay</h2>
								</div>
								<p class="cb"></p>
								<p><b>Address :</b> Darjeeling, West Bengal, India</p>
								<p><b>Facility :</b> Airport Transfer, Car Rental / Hire, Laundry Services, Parking, Wakeup Services</p>
								<div class="mt7px">This is one of the best hotel in darjeeling good rating , neet & clean .</div>
								</td>
								
																	<td class="p10px vat imgWidth150 w150px lh0">
									<div class="demo-wrap">
									<ul class="lsn m0px p0px" id="detailslider2">
																					<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w150px h150px"><a rel="gall" data-fancybox="showZoomImage2" href="https://ttw.wlimg.com/hotel-package-images/photo-big/dir_15/423905/19394.jpg"><img src="https://ttw.wlimg.com/hotel-package-images/photo-small/dir_15/423905/19394.jpg"  height="150" width="148"   alt="Snowlion Homestay" title="Snowlion Homestay" class="bdr"  /></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="showZoomImage2" href="https://ttw.wlimg.com/hotel-package-images/photo-big/dir_15/423905/19396.jpg"><img src="https://ttw.wlimg.com/hotel-package-images/photo-small/dir_15/423905/19396.jpg"  width="150" height="113"    alt="Snowlion Homestay" title="Snowlion Homestay" class="bdr"  /></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="showZoomImage2" href="https://ttw.wlimg.com/hotel-package-images/photo-big/dir_15/423905/19397.jpg"><img src="https://ttw.wlimg.com/hotel-package-images/photo-small/dir_15/423905/19397.jpg"  width="150" height="113"    alt="Inside of Homestay" title="Inside of Homestay" class="bdr"  /></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="showZoomImage2" href="https://ttw.wlimg.com/hotel-package-images/photo-big/dir_15/423905/19398.jpg"><img src="https://ttw.wlimg.com/hotel-package-images/photo-small/dir_15/423905/19398.jpg"  width="150" height="113"    alt="Dulex Room" title="Dulex Room" class="bdr"  /></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="showZoomImage2" href="https://ttw.wlimg.com/hotel-package-images/photo-big/dir_15/423905/19399.jpg"><img src="https://ttw.wlimg.com/hotel-package-images/photo-small/dir_15/423905/19399.jpg"  width="150" height="113"    alt="Breakfast Room" title="Breakfast Room" class="bdr"  /></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="showZoomImage2" href="https://ttw.wlimg.com/hotel-package-images/photo-big/dir_15/423905/19400.jpg"><img src="https://ttw.wlimg.com/hotel-package-images/photo-small/dir_15/423905/19400.jpg"  width="150" height="113"    alt="dulex Room" title="dulex Room" class="bdr"  /></a></p></div></li>
																					</ul>
									</div>
									</td>
																	
								</tr>
								</table>
								</div>
																	<div id="show_more_content" style="display:none;">
																		<div class="data lh13em p20px aj mb7px">
									<table class="w100 formTable bdr0 imgWidth">
									<tr>
									<td class="p10px"><p class="fr lh0">
									
																			<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_on.png" alt=""/>
																				<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_on.png" alt=""/>
																				<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_off.png" alt=""/>
																				<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_off.png" alt=""/>
																				<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_off.png" alt=""/>
																				<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_off.png" alt=""/>
																				<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_off.png" alt=""/>
																			
									</p>
									<div class="mb5px">
									<h2 class="dif b xxlarge">Snowlion Homestay</h2>
									</div>
									<p class="cb"></p>
									<p><b>Address :</b> Darjeeling, West Bengal, India</p>
									<p><b>Facility :</b> Airport Transfer, Car Rental / Hire, Laundry Services, Parking, Wakeup Services</p>
									<div class="mt7px">This is one of the best hotel in darjeeling good rating , neet & clean .</div>
									</td>
									
																			<td class="p10px vat imgWidth150 w150px lh0">
										<div class="demo-wrap">
										<ul class="lsn m0px p0px" id="detailslider3">
																							<li class="bdr bw3px c5px p1px"><div class="f150x150"><p class="ac vam"><a rel="gall" data-fancybox="showZoomImage3" href="https://ttw.wlimg.com/hotel-package-images/photo-big/dir_15/423905/19394.jpg"><img src="https://ttw.wlimg.com/hotel-package-images/photo-small/dir_15/423905/19394.jpg"  height="150" width="148"   alt="Snowlion Homestay" title="Snowlion Homestay" class="bdr"  /></a></p></div></li>
																										<li class="bdr bw3px c5px p1px"><div class="f150x150"><p class="ac vam"><a rel="gall" data-fancybox="showZoomImage3" href="https://ttw.wlimg.com/hotel-package-images/photo-big/dir_15/423905/19396.jpg"><img src="https://ttw.wlimg.com/hotel-package-images/photo-small/dir_15/423905/19396.jpg"  width="150" height="113"    alt="Snowlion Homestay" title="Snowlion Homestay" class="bdr"  /></a></p></div></li>
																										<li class="bdr bw3px c5px p1px"><div class="f150x150"><p class="ac vam"><a rel="gall" data-fancybox="showZoomImage3" href="https://ttw.wlimg.com/hotel-package-images/photo-big/dir_15/423905/19397.jpg"><img src="https://ttw.wlimg.com/hotel-package-images/photo-small/dir_15/423905/19397.jpg"  width="150" height="113"    alt="Inside of Homestay" title="Inside of Homestay" class="bdr"  /></a></p></div></li>
																										<li class="bdr bw3px c5px p1px"><div class="f150x150"><p class="ac vam"><a rel="gall" data-fancybox="showZoomImage3" href="https://ttw.wlimg.com/hotel-package-images/photo-big/dir_15/423905/19398.jpg"><img src="https://ttw.wlimg.com/hotel-package-images/photo-small/dir_15/423905/19398.jpg"  width="150" height="113"    alt="Dulex Room" title="Dulex Room" class="bdr"  /></a></p></div></li>
																										<li class="bdr bw3px c5px p1px"><div class="f150x150"><p class="ac vam"><a rel="gall" data-fancybox="showZoomImage3" href="https://ttw.wlimg.com/hotel-package-images/photo-big/dir_15/423905/19399.jpg"><img src="https://ttw.wlimg.com/hotel-package-images/photo-small/dir_15/423905/19399.jpg"  width="150" height="113"    alt="Breakfast Room" title="Breakfast Room" class="bdr"  /></a></p></div></li>
																										<li class="bdr bw3px c5px p1px"><div class="f150x150"><p class="ac vam"><a rel="gall" data-fancybox="showZoomImage3" href="https://ttw.wlimg.com/hotel-package-images/photo-big/dir_15/423905/19400.jpg"><img src="https://ttw.wlimg.com/hotel-package-images/photo-small/dir_15/423905/19400.jpg"  width="150" height="113"    alt="dulex Room" title="dulex Room" class="bdr"  /></a></p></div></li>
																							</ul>
										</div>
										</td>
																			
									</tr>
									</table>
									</div>
																		<div class="data lh13em p20px aj mb7px">
									<table class="w100 formTable bdr0 imgWidth">
									<tr>
									<td class="p10px"><p class="fr lh0">
									
																			<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_on.png" alt=""/>
																				<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_on.png" alt=""/>
																				<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_on.png" alt=""/>
																				<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_on.png" alt=""/>
																				<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_off.png" alt=""/>
																				<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_off.png" alt=""/>
																				<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_off.png" alt=""/>
																			
									</p>
									<div class="mb5px">
									<h2 class="dif b xxlarge">Summit Hotels & Resorts</h2>
									</div>
									<p class="cb"></p>
									<p><b>Address :</b> Darjeeling, West Bengal, India</p>
									<p><b>Facility :</b> 24-Hour Front Desk, Airport Transfer, Banquet, Baby Sitting, Bar/Lounge, Car Rental / Hire, Laundry Services, Restaurant, Security Guard, Sauna & Spa, Wakeup Services</p>
									<div class="mt7px">This hotel are good need and clean</div>
									</td>
									
																			<td class="p10px vat imgWidth150 w150px lh0">
										<div class="demo-wrap">
										<ul class="lsn m0px p0px" id="detailslider4">
																							<li class="bdr bw3px c5px p1px"><div class="f150x150"><p class="ac vam"><a rel="gall" data-fancybox="showZoomImage4" href="https://ttw.wlimg.com/hotel-package-images/photo-big/dir_15/423905/19401.jpg"><img src="https://ttw.wlimg.com/hotel-package-images/photo-small/dir_15/423905/19401.jpg"  width="150" height="116"    alt="Hill Adventure Tour" title="Hill Adventure Tour" class="bdr"  /></a></p></div></li>
																										<li class="bdr bw3px c5px p1px"><div class="f150x150"><p class="ac vam"><a rel="gall" data-fancybox="showZoomImage4" href="https://ttw.wlimg.com/hotel-package-images/photo-big/dir_15/423905/19402.jpg"><img src="https://ttw.wlimg.com/hotel-package-images/photo-small/dir_15/423905/19402.jpg"  width="150" height="88"    alt="Hill Adventure Tour" title="Hill Adventure Tour" class="bdr"  /></a></p></div></li>
																										<li class="bdr bw3px c5px p1px"><div class="f150x150"><p class="ac vam"><a rel="gall" data-fancybox="showZoomImage4" href="https://ttw.wlimg.com/hotel-package-images/photo-big/dir_15/423905/19403.jpg"><img src="https://ttw.wlimg.com/hotel-package-images/photo-small/dir_15/423905/19403.jpg"  width="150" height="88"    alt="Hill Adventure Tour" title="Hill Adventure Tour" class="bdr"  /></a></p></div></li>
																										<li class="bdr bw3px c5px p1px"><div class="f150x150"><p class="ac vam"><a rel="gall" data-fancybox="showZoomImage4" href="https://ttw.wlimg.com/hotel-package-images/photo-big/dir_15/423905/19404.jpg"><img src="https://ttw.wlimg.com/hotel-package-images/photo-small/dir_15/423905/19404.jpg"  width="150" height="56"    alt="Spa & Yoga" title="Spa & Yoga" class="bdr"  /></a></p></div></li>
																							</ul>
										</div>
										</td>
																			
									</tr>
									</table>
									</div>
																	</div>
																<p class="mt10px ac"><a class="buttonBig p5px10px dib b" id="more_button" href="javascript:topDestinationToggle('show_more_content','more_button');" >View More &#9660;</a></p>
															<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>Transport</li>
															</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Off Road Adventure is a fully licensed and registered adventure and trekking company in India and recognized by the tourism authority of the government of India to run tours, trekking, Peak climbing, mountaineering expeditions and other travel related activities.</li><li>
You can book holiday in confidence that your money is protected because we are fully licensed and affiliated with Gorkhaland Territorial administration , Department of Tourism Darjeeling . Lonely Planet . Trip advisor . Himalayan Mountaineering Institute . Indian Mountaineering Foundation .</li><li>
Here are copies of all our licenses and authorizations :</li><li>
Darjeeling Tourism Department , India</li><li>
Indian Mountaineering Foundation</li><li>
Himalayan Mountaineering Foundation</li><li>
Sikkim Amateur Mountaineering Association</li><li>
Eastern Himalayan Darjeeling Guide Association</li><li>
Himachal Paragliding Association</li><li>
Darjeeling Paragliding Association</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.grihapraveshtravels.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Hill Adventure 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="111574"/>
						</form>
						</div>
						
						";i:1;s:59:"Book Hill Adventure Tour - 9 Nights / 10 Days Tour Packages";i:2;s:112:"book hill adventure tour - 9 nights / 10 days tour packages, paragliding tour packages, darjeeling tour packages";i:3;s:149:"Grihapravesh Travels offers Hill Adventure Tour - 9 Nights / 10 Days tour package, budget Paragliding tour packages for Darjeeling at exciting price.";i:4;s:4090:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Darjeeling"        
		                 },
		      "description": "We take pleasure to welcome you to the Official Website of Off Road Adventure!! Off Road Adventure is India Government registered reliable Adventure Company set up by highly knowledgeable tourism professionals with over 10 years of experience in the industry. We are Darjeeling and Sikkim based adventure and trekking company, our office headquarter is located in both Darjeeling and Sikkim state.It has been established as the premier service provider for adventure holidays in India, Nepal and Bhutan. All of our team members are familiar with nature with most having grown up in the Himalayas. Off Road adventure offers activity like Trekking, Mountaineering Expedition, Paragliding, Rafting, Rock Climbing, Camping etc. We are committed in environmental friendly tourism activities and we take pride in doing our part to preserve the natural beauty, respect the way of life of host community, and their local culture and heritage. Our Clients safety, security, comfort and satisfaction are of paramount importance to us. We strive to ensure that each experience with us is fulfilling and memorable.Off Road Adventure was also official adventure partner of "GORKHALAND TERRITORIAL ADMINISTRATION" for 4 years after being the No 1 Adventure and Trekking provider of Darjeeling region. You have known us for years. You have heard or read about our success stories. Some of you have even tried our services and appreciated the quality and the professionalism we deliver. Now, it’s time to get acquainted with the force behind this success, ‘ OUR TEAM ‘.

Though we come from different field, all of us involved with Off Road Adventure are driven by a common goal, that is; to utilize personal skills, knowledge and experience to deliver the highest level of customer satisfaction through exclusive trekking experience, and promote the tourism industry of the country in every possible way. To make this happen, we provide exceptionally active administration and diligent and smart off-site staffs that are very passionate about the things they do. Together, we come up with innovative ideas to provide some of the most wonderful opportunities to trekkers who are planning their trek in the land on India, Nepal and Bhutan.

Off Road adventure team is divided into two teams, on-site and off-site team. Each member of the team are handpicked so that they can best utilize their potential to design a wonderful holiday for you. Also, each member whether is be from the on-site team or the off-site team, is considered as an asset of this company. Let’s get introduced to some of the members of our team.Paragliding in Darjeeling
Mountain Biking Tours
Rafting in Darjeeling
Camping in Darjeeling
Jeep safari to singalila national park
Rock climbing
Sport climbing
KayakingOff Road Adventure is a fully licensed and registered adventure and trekking company in India and recognized by the tourism authority of the government of India to run tours, trekking, Peak climbing, mountaineering expeditions and other travel related activities.

You can book holiday in confidence that your money is protected because we are fully licensed and affiliated with Gorkhaland Territorial administration , Department of Tourism Darjeeling . Lonely Planet . Trip advisor . Himalayan Mountaineering Institute . Indian Mountaineering Foundation .

Here are copies of all our licenses and authorizations :

Darjeeling Tourism Department , India
Indian Mountaineering Foundation
Himalayan Mountaineering Foundation
Sikkim Amateur Mountaineering Association
Eastern Himalayan Darjeeling Guide Association
Himachal Paragliding Association
Darjeeling Paragliding Association07-1110-03",
		      "name": "Hill Adventure Tour",
		      "telephone": "+91-9800718321"
		    }
		    </script>
			";i:5;N;}