a:6:{i:0;s:23537:"				<div class="h1"><h1>Heaven Himachal by Car Ex-Delhi Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.grandindiatrip.com/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.grandindiatrip.com/tour-packages.htm" title="Tour Packages">Tour Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Heaven Himachal by Car Ex-Delhi 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">Tour Code </td>
						<td class="p5px pl0px vat">Himachal tours</td>
						</tr>
												<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">Chandigarh City, Dalhousie, Manali, Shimla, Dharamshala</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 11950 Per Person						</td>
						</tr>
												<tr>
						<td class="b p5px dif w125px vat">Special Offer </td>
						<td class="p5px pl0px dif vat">Remarks<br />
The rates are subjects to change without any prior notice.<br />
Accommodation in the itinerary at the mentioned hotels or the similar hotels.</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.grandindiatrip.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Heaven Himachal by Car Ex-Delhi 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="59786"/>
						</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_9/257644/112559.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/112559.jpg"  width="150" height="150"    alt="Heaven Himachal by Car Ex-Delhi Tour" title="Heaven Himachal by Car Ex-Delhi Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					Welcome to Himachal<br />
Book Specials Himachal Tour & travel packages at Tourism-Himachal.com .Himachal Tour & holiday Packages can be customized.Plan a travel to Himachal and its various tourist attractions with Himachal holiday packages. Explore exciting Himachal Tourism with cheap vacation. Himachal travel packages, Manali-Shimla Package, Spl Himachal Tour Package, Manali Tour Package,Great Himachal Tour Package.<br />
<b>About Himachal</b><br />
<br />
Situated in North India, Himachal Pradesh (Abode of Snow) is surrounded by Jammu & Kashmir on the north; Punjab, Haryana, Uttar Pradesh to the south; Uttaranchal to the south east and the Chinese territory of Tibet to the east. The state is mostly covered by the low Shivalik hill range towards the south and the dramatically high trans-Himalayan ranges as you go north. Thus you can proceed from hill-town Dharamsala in the south, at 1700m, to Lahaul-and-Spiti, the northernmost district, at 6500m. This geography and the resultant cool-to-snowy climate, define Himachal's tourist attractions as well; in fact, tourism and apple-growing run the economy of the state. Sutlej, Beas, Ravi, and Parbati are the main rivers. <br />
Himachal Top Destination<br />
<b>Shimla</b><br />
Shimla is said as Queen of the hill. It derives its name from Shyamala. Shimla has a great geographical value in India. If we return back to Indian history then we will found that the city was the capital town of India in the time period of British. <br />
<br />
They used this place as capital town in summer season and usually they said Shimla as Simla. The weather, environment and the natural beauties are so comfortable throughout the year that you can trip here any time of a year. You can choose it as your honeymoon destination.<br />
<br />
<br />
<b>Kufri</b><br />
Kufri is a charming hill resort at the foothills of Himalayas, positioned at the southern part of Himachal Pradesh 13 kms from Shimla. The picturesque place is branded for its pleasant type of weather and beautiful magnificence. Positioned at an elevation of 2,510 meters in the tiny state of Himachal, Kufri is 13 km away from the Shimla on the National Highway No.22 (NH22). a good number of the vacationers impending to Shimla adore to stopover at this hill station. It is also known as the "winter sports capital" of Himachal Pradesh. Moreover, Kufri is acknowledged for the previous ski incline in the state.<br />
<br />
<br />
<b>Manali</b><br />
A beautiful hill station in Himachal Pradesh, nestled in between snowy mountains and thick forests, flanked by the Beas River, Manali is truly a travelers paradise. Situated at an altitude of 1950 meters, Manali offers stunning views of the Pir Panjal and Dhauladhar range of mountains, which are considered to be the dwelling place of Gods and Goddesses. Legend has it that Manali was founded by an ancient sage Manu whose ark found its resting place here after a great flood. Manali, which literally means "the resting place of Manu" is a popular tourist destination and offers a welcome respite from the heat of the plains during the summer months.<br />
<br />
 <br />
<br />
<b>Kullu</b><br />
Kullu (1220m) was once known as Kulanthapitha - the end of the habitable world. Beyond rose the forbidding heights of the Greater Himalaya, and by the banks of the shining river Beas lay the fabled Silver Valley. Kullu got its first motorable access only after independence. The long centuries of seclusion have however allowed the area to retain a considerable measures of its traditional charm. Here is the core of an intricate web of numerous valleys, each of which is a visual delight and seems more beautiful than the other. <br />
<br />
The Silver Valley has nature's treasures that lie carelessly scattered as flowers. This wealth nestles by every tree in the splendid forests, bursts forth in the blooms and in the fruit of every orchard. Here are riches which cannot be measured and echo down the ages with the words of every myth and ancient legend and glow in the warm smiles of its gentle people. There is pleasure in every step you take in these enchanted valleys and in every gurgle you hear in the clear mountain streams.<br />
 <br />
<br />
<b>Solan</b><br />
Positioned at the apex of Kullu valley, Solang Nullah comprises of giant sloppy lawns. Solang valley is popular for its sports conditions like paragliding, zorbing, parachuting, skating, horse riding etc. during the climate of summer. The valley is around 14 Kms from Manali which possesses a glacier nearby. Blown up by means of wonderful picnic spots, the astounding ski slopes at this juncture are occupied with hectic activities during the month of January and February. The Manali climbing institution gives an exceptional guidance in skiing for the ones who fancy learning. This magnificent consign is also the hub of the yearly wintry weather skiing fiesta. The gorge also grips a shrine of Lord Shiva on the hill top. Traditionally known as the Snow point, Solang Valley is an ideal position for skiing and the 300 meter ski plagiarize is the chief charm of this eye-catching picnic site.<br />
 <br />
<br />
<b>Kangra</b><br />
Kangra district obtains its name from Kangra town which was primarily called as Nagarkot in the ancient age. The modern Kangra district was founded on the 1st September, 1972 by the Government of Himachal Pradesh. The people of Kangra district mainly follow the Hindu religions and some other religions (Muslim, Buddhists, Sikhs, Christians and Janis) are also followed by few people. Most of the Hindus are Rajputs Brahmins and Scheduled Cast in Kangra district. <br />
<br />
Kangra district forest is full of various animals and birds some of them are rare species. The animals that are found in the district are Ghoral, Kakar, Kastura, Aimu, Thar, Samber, Ibex, Blue mountain sheep, Black Bear, Brown Bear, Leopard, Snow Leopard, Wild Boar, Spotted Deer, Porcupine, Flying squirrel etc. and the birds that are found in Kangra are Snow cock, Western horned, Pea-cock, Ring dove, Spotted dove, parrot, tawny eagle, green pigeon, pigeon, tits, nut cracker, Pies, Woodpecker, Crow, Himalayan fly catcher etc.<br />
<br />
<br />
<b>Dharamshala</b><br />
Dharamshala, is located at the Dhauladhar drive and has been accredited as the headqyuarters of Kangra district in the year 1855 bduring the rule of the British Era. It elongates from war commemorative plaque tombstone to Mcleodganj and moves downhill to the basin gorges of the South. The two categorizations ofDharamshala, specifically the upper and lower Dharamshala are legendary for its emerald green calmness of intelligence. Sprint sour your foot at this defrayal and travel around the great quantity of leisure time avenues for instance the renowned coffee shops, snooker tables and what not with the Dharamshala Tourism. The city is overwhelmed beneath the positivity of Tibetan sway and is a conspicuous intermingle of multi distinguished trend. <br />
<br />
what is more are the supercilious rise in addition appends corporal to this hilarity and is a excruciating position with the enthralled sounds and tourist attractions of antique Tibet even after encompassing a contemporary point of view. The temples and monasteries here for example Adi Shakti Temple at Naddi, Indru Nag Temple, Masrur (rock cut temple), Namgyal Monastery, Norbulingka Institute and the St. John’s Church etc. stopover at wall these places for sightseeing in Dharamshala which is a dwelling of certainty, harmony and indulgencewith the Tourism in Dharamshala. <br />
<br />
Himachal Tour packages provides you with the scintilatting tour packages of Dharamshala.<br />
<br />
<br />
<b>Dalhousie</b><br />
Dalhousie is popularly known as the gateway to ancient Chamba Hill State. Located in the Chamba region of Himachal Pradesh this hill location of Dalhousie is chock-full of allure and embraces enduring reverberation and wraps up in the locale of about 14 sq. km and is fabricated on the renowned five hills - Kathlog, Potreyn, Tehra, Bakrota and Balun. It is a magnet to ample number of tourists throughout the year and also bids diverse experiences at some point in all the seasons. Highlighting the architecture it includes a variety from gothic churches to the ancient Hindu temples. This astounding hill station is nourished and cared in the lap of thriving green pine forests and rabbles the vacationers in quest of safe haven from the sizzling temperature of the plains. <br />
<br />
The nourished nature of Dalhousie is positioned at the peak range of Himalayas on the western edge of Dhauladhar hill top. Enclosed in a gorgeous panorama of ice-capped mountains the heavenly place is sited above sea level at an altitude of 6000-9000 ft. The specialty of the state is a bouquet ancient Hindu culture, art, temples, and handicrafts and also Scottish and Victorian architecture which is very rampant since the mid-6th century here in the town.<br />
( Shimla 02 nights) ( Manali 03 nights ) ( Dharamsala 01 night ) ( Dalhousie 2 nights ) ( Chandigarh 01 Night )Remarks<br />
The rates are subjects to change without any prior notice.<br />
Accommodation in the itinerary at the mentioned hotels or the similar hotels.Any monument entry fees / camera fees.<br />
Any meal, which is not mentioned above.<br />
Any guide charges.<br />
Any air / train fare.<br />
3.09% Government service tax extra.10-0530-09<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> Delhi - Shimla (370 Kms- 9 Hrs)
								</p>
								<p class="aj">On Arrival at Delhi Airport/Railway station our representative will receive you .Drive to Shimla. Overnight stay in Shimla</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> Shimla - Kufri - Shimla
								</p>
								<p class="aj">After breakfast explore Shimla City .Visit Jakhu temple and Kufri. Kufri situated at an altitude of 2500 meters just an hour’s drive from Shimla. In the evening Visit Ridge & Mall Road, Scandal Point, Kali Bari, Gaiety Theater. Overnight stay at Hotel.</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 3:</b> Shimla - Manali - Via Manikaran and Kullu Valley.
								</p>
								<p class="aj">After breakfast you will proceed by road to Manali (274 kms / 7hrs). On the way sight-seeing like Sundernagar Lake, Pandoh dam, Vaishno Devi Temple, Kullu, Manikaran and overnight stay at hotel in Manali.</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> Manali - Rohtang Pass (Up to snow line) Rohtang is closed on Tuesday
								</p>
								<p class="aj">After Breakfast proceed towards Rohtang snow point 51 km from Manali at an altitude of 3978 meters and on the way back from snow point visit Solang Valley and overnight stay in Hotel.</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 5:</b> Manali Local
								</p>
								<p class="aj">After breakfast visit "Hadimba temple". It was built in 1553 with a superbly crafted four tiered pagoda roof; it is famous for its exquisitely carved doorway. "club house" The Club House with its comprehensive facilities that include a roller skating rink, an auditorium, billiards rooms, a library, a bar and restaurant makes wonderful outing for the day." Tibetan Monastery, Van Vihar, and "Vashisth" Well known for its hot springs. There are old temples dedicated to the sage Vashisth and to Lord Rama. Overnight stay in Hotel.</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 6:</b> Manali - Dharamsala (235 Km)
								</p>
								<p class="aj">After breakfast Travel by surface from Manali to Mc Leodganj (Dharamsala).On arrival check in at hotel. Evening half day city tour visiting Dal Lake, Church, Bhagsu Nag Temple and Tibetan Monastery. Overnight at hotel.</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 7:</b> Dharamsala - Dalhousie (143 Km)
								</p>
								<p class="aj">After breakfast leave for Dalhousie. visit Mcleodganj, Naddi Dal Lake and transfer to Dalhousie check in hotel overnight at hotel.</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 8:</b> Dalhousie - Khajjiar - Dalhousie
								</p>
								<p class="aj">After breakfast full day sightseeing first drive to Subash Bowli then to Khajjiar via Bakrota hills and Lakkarmandi reach Khajjiar full day excursion. Evening visit mall road overnight at hotel.</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 9:</b> Dalhousie - Chandigarh (302 Km)
								</p>
								<p class="aj">After breakfast drive towards Chandigarh. Approx. 10 hrs. Journey. Check in to hotel & overnight stay.</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 10:</b> Chandigarh Local - Delhi (238 Km)
								</p>
								<p class="aj">After breakfast leave for local sightseeing such as rose garden, rock garden & Sukhna Lake. In the afternoon leave for Delhi drop at Railway station/Airport to catch onwards train/flight & back to home with sweet memories.</p>
								</td>
								</tr>
								</table>					
								</div>						<br />
												 <p class="headHr p7px b pl10px xlarge">Tour Detail</p>
			             <div class="data p15px aj">
										
						<p class="large b mb5px dif">Inclusions :</p>
						<ul>
															<li>Hotel</li>
																		<li>Sightseeing</li>
																		<li>Transport</li>
															</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Any monument entry fees / camera fees.</li><li>
Any meal, which is not mentioned above.</li><li>
Any guide charges.</li><li>
Any air / train fare.</li><li>
3.09% Government service tax extra.</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. ~^#^~						
    	<p class="h dif xlarge b mb5px">Package Cost:</p>
    	<div class="otherDetails aj">Per Person rates are based on twin sharing</div><br>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Cars/ Package Category</td>
				<td class="headHr p5px b">Budget</td>
				<td class="headHr p5px b">DELUXE</td>
				<td class="headHr p5px b">SUPER DELUXE</td>
				<td class="headHr p5px b">LUXURY</td>
			</tr>
			<tr>
				<td class="headVr p5px">Indica 2 PAX)</td>
				<td class="data p5px">18,850</td>
				<td class="data p5px">23,660</td>
				<td class="data p5px">26,390</td>
				<td class="data p5px">29,120</td>
			</tr>
			<tr>
				<td class="headVr p5px">Tavera 4 PAX)</td>
				<td class="data p5px">16,250</td>
				<td class="data p5px">18,460</td>
				<td class="data p5px">21,190</td>
				<td class="data p5px">23,660</td>
			</tr>
			<tr>
				<td class="headVr p5px">Tavera 6 PAX)</td>
				<td class="data p5px">10,920</td>
				<td class="data p5px">13,260</td>
				<td class="data p5px">15,990</td>
				<td class="data p5px">18,460</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Hotel Category</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Hotel Category/Package Type</td>
				<td class="headHr p5px b">Budget</td>
				<td class="headHr p5px b">DELUXE</td>
				<td class="headHr p5px b">SUPER DELUXE</td>
				<td class="headHr p5px b">LUXURY</td>
			</tr>
			<tr>
				<td class="headVr p5px">Shimla Hotel</td>
				<td class="data p5px">Hotel Eve/Himani</td>
				<td class="data p5px">Silverine</td>
				<td class="data p5px">Bridge View Regency</td>
				<td class="data p5px">Hotel Landmark</td>
			</tr>
			<tr>
				<td class="headVr p5px">Manali Hotel</td>
				<td class="data p5px">Hotel Century, Gangri</td>
				<td class="data p5px">Hotel Apple green / Apple Paradise</td>
				<td class="data p5px">Hotel Royal regency</td>
				<td class="data p5px">Shingar regency /Manali Heights / The Royal grand</td>
			</tr>
			<tr>
				<td class="headVr p5px">Dharamshala Hotel</td>
				<td class="data p5px">Hotel Buddha Valley / Tirund / Anand Palace</td>
				<td class="data p5px">Hotel Spring Valley</td>
				<td class="data p5px">Hotel Spring Valley / Sapphire</td>
				<td class="data p5px">Surya Resort</td>
			</tr>
			<tr>
				<td class="headVr p5px">Dalhousie Hotel</td>
				<td class="data p5px">New Palace</td>
				<td class="data p5px">Alps Spa & Resort</td>
				<td class="data p5px">Alps Spa & Resort</td>
				<td class="data p5px">Snow Valley resort</td>
			</tr>
			<tr>
				<td class="headVr p5px">Chandigarh Hotel</td>
				<td class="data p5px">Hotel Kailash Palace</td>
				<td class="data p5px">Classic Residency</td>
				<td class="data p5px">Hotel Sun Park</td>
				<td class="data p5px">Hotel Sun Park</td>
			</tr>
		</table></div><br>						</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.grandindiatrip.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Heaven Himachal by Car Ex-Delhi 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="59786"/>
						</form>
						</div>
						
						";i:1;s:76:"Book Heaven Himachal by Car Ex-Delhi Tour - 9 Nights / 10 Days Tour Packages";i:2;s:169:"book heaven himachal by car ex-delhi tour - 9 nights / 10 days tour packages, valley tour packages, chandigarh city, dalhousie, manali, shimla, dharamshala tour packages";i:3;s:213:"Grand India Tours & Travels offers Heaven Himachal by Car Ex-Delhi Tour - 9 Nights / 10 Days tour package, budget Valley tour packages for Chandigarh City, Dalhousie, Manali, Shimla, Dharamshala at exciting price.";i:4;s:9636:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Chandigarh City, Dalhousie, Manali, Shimla, Dharamshala"        
		                 },
		      "description": "Welcome to Himachal
Book Specials Himachal Tour & travel packages at Tourism-Himachal.com .Himachal Tour & holiday Packages can be customized.Plan a travel to Himachal and its various tourist attractions with Himachal holiday packages. Explore exciting Himachal Tourism with cheap vacation. Himachal travel packages, Manali-Shimla Package, Spl Himachal Tour Package, Manali Tour Package,Great Himachal Tour Package.
<b>About Himachal</b>

Situated in North India, Himachal Pradesh (Abode of Snow) is surrounded by Jammu & Kashmir on the north; Punjab, Haryana, Uttar Pradesh to the south; Uttaranchal to the south east and the Chinese territory of Tibet to the east. The state is mostly covered by the low Shivalik hill range towards the south and the dramatically high trans-Himalayan ranges as you go north. Thus you can proceed from hill-town Dharamsala in the south, at 1700m, to Lahaul-and-Spiti, the northernmost district, at 6500m. This geography and the resultant cool-to-snowy climate, define Himachal's tourist attractions as well; in fact, tourism and apple-growing run the economy of the state. Sutlej, Beas, Ravi, and Parbati are the main rivers. 
Himachal Top Destination
<b>Shimla</b>
Shimla is said as Queen of the hill. It derives its name from Shyamala. Shimla has a great geographical value in India. If we return back to Indian history then we will found that the city was the capital town of India in the time period of British. 

They used this place as capital town in summer season and usually they said Shimla as Simla. The weather, environment and the natural beauties are so comfortable throughout the year that you can trip here any time of a year. You can choose it as your honeymoon destination.


<b>Kufri</b>
Kufri is a charming hill resort at the foothills of Himalayas, positioned at the southern part of Himachal Pradesh 13 kms from Shimla. The picturesque place is branded for its pleasant type of weather and beautiful magnificence. Positioned at an elevation of 2,510 meters in the tiny state of Himachal, Kufri is 13 km away from the Shimla on the National Highway No.22 (NH22). a good number of the vacationers impending to Shimla adore to stopover at this hill station. It is also known as the "winter sports capital" of Himachal Pradesh. Moreover, Kufri is acknowledged for the previous ski incline in the state.


<b>Manali</b>
A beautiful hill station in Himachal Pradesh, nestled in between snowy mountains and thick forests, flanked by the Beas River, Manali is truly a travelers paradise. Situated at an altitude of 1950 meters, Manali offers stunning views of the Pir Panjal and Dhauladhar range of mountains, which are considered to be the dwelling place of Gods and Goddesses. Legend has it that Manali was founded by an ancient sage Manu whose ark found its resting place here after a great flood. Manali, which literally means "the resting place of Manu" is a popular tourist destination and offers a welcome respite from the heat of the plains during the summer months.

 

<b>Kullu</b>
Kullu (1220m) was once known as Kulanthapitha - the end of the habitable world. Beyond rose the forbidding heights of the Greater Himalaya, and by the banks of the shining river Beas lay the fabled Silver Valley. Kullu got its first motorable access only after independence. The long centuries of seclusion have however allowed the area to retain a considerable measures of its traditional charm. Here is the core of an intricate web of numerous valleys, each of which is a visual delight and seems more beautiful than the other. 

The Silver Valley has nature's treasures that lie carelessly scattered as flowers. This wealth nestles by every tree in the splendid forests, bursts forth in the blooms and in the fruit of every orchard. Here are riches which cannot be measured and echo down the ages with the words of every myth and ancient legend and glow in the warm smiles of its gentle people. There is pleasure in every step you take in these enchanted valleys and in every gurgle you hear in the clear mountain streams.
 

<b>Solan</b>
Positioned at the apex of Kullu valley, Solang Nullah comprises of giant sloppy lawns. Solang valley is popular for its sports conditions like paragliding, zorbing, parachuting, skating, horse riding etc. during the climate of summer. The valley is around 14 Kms from Manali which possesses a glacier nearby. Blown up by means of wonderful picnic spots, the astounding ski slopes at this juncture are occupied with hectic activities during the month of January and February. The Manali climbing institution gives an exceptional guidance in skiing for the ones who fancy learning. This magnificent consign is also the hub of the yearly wintry weather skiing fiesta. The gorge also grips a shrine of Lord Shiva on the hill top. Traditionally known as the Snow point, Solang Valley is an ideal position for skiing and the 300 meter ski plagiarize is the chief charm of this eye-catching picnic site.
 

<b>Kangra</b>
Kangra district obtains its name from Kangra town which was primarily called as Nagarkot in the ancient age. The modern Kangra district was founded on the 1st September, 1972 by the Government of Himachal Pradesh. The people of Kangra district mainly follow the Hindu religions and some other religions (Muslim, Buddhists, Sikhs, Christians and Janis) are also followed by few people. Most of the Hindus are Rajputs Brahmins and Scheduled Cast in Kangra district. 

Kangra district forest is full of various animals and birds some of them are rare species. The animals that are found in the district are Ghoral, Kakar, Kastura, Aimu, Thar, Samber, Ibex, Blue mountain sheep, Black Bear, Brown Bear, Leopard, Snow Leopard, Wild Boar, Spotted Deer, Porcupine, Flying squirrel etc. and the birds that are found in Kangra are Snow cock, Western horned, Pea-cock, Ring dove, Spotted dove, parrot, tawny eagle, green pigeon, pigeon, tits, nut cracker, Pies, Woodpecker, Crow, Himalayan fly catcher etc.


<b>Dharamshala</b>
Dharamshala, is located at the Dhauladhar drive and has been accredited as the headqyuarters of Kangra district in the year 1855 bduring the rule of the British Era. It elongates from war commemorative plaque tombstone to Mcleodganj and moves downhill to the basin gorges of the South. The two categorizations ofDharamshala, specifically the upper and lower Dharamshala are legendary for its emerald green calmness of intelligence. Sprint sour your foot at this defrayal and travel around the great quantity of leisure time avenues for instance the renowned coffee shops, snooker tables and what not with the Dharamshala Tourism. The city is overwhelmed beneath the positivity of Tibetan sway and is a conspicuous intermingle of multi distinguished trend. 

what is more are the supercilious rise in addition appends corporal to this hilarity and is a excruciating position with the enthralled sounds and tourist attractions of antique Tibet even after encompassing a contemporary point of view. The temples and monasteries here for example Adi Shakti Temple at Naddi, Indru Nag Temple, Masrur (rock cut temple), Namgyal Monastery, Norbulingka Institute and the St. John’s Church etc. stopover at wall these places for sightseeing in Dharamshala which is a dwelling of certainty, harmony and indulgencewith the Tourism in Dharamshala. 

Himachal Tour packages provides you with the scintilatting tour packages of Dharamshala.


<b>Dalhousie</b>
Dalhousie is popularly known as the gateway to ancient Chamba Hill State. Located in the Chamba region of Himachal Pradesh this hill location of Dalhousie is chock-full of allure and embraces enduring reverberation and wraps up in the locale of about 14 sq. km and is fabricated on the renowned five hills - Kathlog, Potreyn, Tehra, Bakrota and Balun. It is a magnet to ample number of tourists throughout the year and also bids diverse experiences at some point in all the seasons. Highlighting the architecture it includes a variety from gothic churches to the ancient Hindu temples. This astounding hill station is nourished and cared in the lap of thriving green pine forests and rabbles the vacationers in quest of safe haven from the sizzling temperature of the plains. 

The nourished nature of Dalhousie is positioned at the peak range of Himalayas on the western edge of Dhauladhar hill top. Enclosed in a gorgeous panorama of ice-capped mountains the heavenly place is sited above sea level at an altitude of 6000-9000 ft. The specialty of the state is a bouquet ancient Hindu culture, art, temples, and handicrafts and also Scottish and Victorian architecture which is very rampant since the mid-6th century here in the town.
( Shimla 02 nights) ( Manali 03 nights ) ( Dharamsala 01 night ) ( Dalhousie 2 nights ) ( Chandigarh 01 Night )Remarks
The rates are subjects to change without any prior notice.
Accommodation in the itinerary at the mentioned hotels or the similar hotels.Any monument entry fees / camera fees.
Any meal, which is not mentioned above.
Any guide charges.
Any air / train fare.
3.09% Government service tax extra.10-0530-09",
		      "name": "Heaven Himachal by Car Ex-Delhi Tour",
		      "telephone": "+91-9415285186"
		    }
		    </script>
			";i:5;N;}