a:6:{i:0;s:16957:"				<div class="h1"><h1>Fabulous Uttarakhand 08Night-09 Days Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.chaturveditravels.com/" title="Home">Home</a> 
				
								
				<b class="ffv p2px">&rsaquo;</b>Fabulous Uttarakhand 08Night-09 Days 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">CTT/49 Fabulous Utta</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Duration </td>
						<td class="p5px pl0px vat">
						8 Nights / 9 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">New Delhi, Mussoorie, Haridwar, Nainital, Ranikhet</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 29099 Per Person						</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.chaturveditravels.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Fabulous Uttarakhand 08Night-09 Days 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="27860"/>
						</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_8/229281/56019.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_8/229281/56019.jpg"  width="150" height="150"    alt="Favulous Darjeeling" title="Favulous Darjeeling" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					Any Airfare, Train Fare, Overland Journey Which Is Not Mentioned In The Itinerary.<br />
Any Personal Nature Items Like Laundry, Bar Bills, Table Bills, Camera Fee, Tips Or Any Other Item.<br />
Guide / Entry Fees / Boatings /Horse Ridings Etc. During Sight Seeings<br />
Any Medical /Rescue Evacuation Due To Mishaps. <br />
Optional Activities Mentioned In The Itinerary <br />
Any Other Things That Is Not Included In The “Package Cost Includes” Column.<br><br>Note:<br />
Any Changes In Govt. Taxes, Hotel Tariff, Etc Will Be Intimated Before Confirming The Package. <br />
Cost Incidental To Any Change In The Itinerary/ Stay On Account Of Flight Cancellation Due To Bad Weather, Ill Health, Roadblocks And/Or Any Factors Beyond Control. <br />
Government Service Tax @ 3.09 Extra <br />
Every Passenger Is Traveling On His Own Responsibility. The Company Will Not Be Responsible For Any Loss Of Luggage Or Any Accidents. We Are Not Responsible For Theft Or Damage To Your Luggage.<br />
Also Note That Video & Audio Systems Are Prohibited In Commercial Vehicles As Per Law And We Do Not Guarantee For It Always.<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> Arrive Delhi
								</p>
								<p class="aj">Arrive Delhi Meet assist at the airport/railway station and transfer to hotel. Later proceed for half day sightseeing tour of Delhi covering Laxmi Narayan Temple, Qutab Minar, India Gate, President house. Later back to hotel.  Rest of the day free at leisure. overnight stay at hotel at Delhi.</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> Delhi - Haridwar (250kms - 5 hrs)
								</p>
								<p class="aj">After breakfast check out from hotel drive to Haridwar.<br />
Haridwar: Meaning ‘Gateway to God’ is one of the seven holiest places of the Hindus, located on the banks of River Ganges. It is the place where river Ganga descends to the plains. Haridwar is also spelled asHardwar or Hari- Dwar. Haridwar is also one of the four places where drops of Amrit or nectar fell from the pitcher which was being carried by Garuda, the heavenly bird and the spot is known as Brahma Kund or Har-ki-Pauri. <br />
On arrival at Haridwar,transfer to hotel, Check into Hotel.take rest ,Afternoon visit Har ki Pairi and Mansa Devi Temple.Evening attend the Sunset Ganga Aarti at bank of river.later back to hotel.free for leisure activities. Overnight stay at hotel at Haridwar.</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> Haridwar - Rishikesh - Mussoorie(80 kms 02hrs)
								</p>
								<p class="aj">After breakfast check out from hotel then drive to Mussoorie.<br />
Mussoorie: is a wonderful hill station in Uttaranchal.It is situated at the foothills of the Himalayas and is known as the Queen of the Hills. Mussoorie derives its name from the plants of Mussoorie or shrubmansoor which are available in large quantities in this region. The lush green hills, the varied flora and fauna and the majestic view of the Shivalik ranges and the Doon Valley attracts hundreds of tourists both domestic and international to Mussoorie each year. Mussoorie is famous not only for its scenic beauty but it has also developed into an important center of education and business. Mussoorie is also famous for the Lal Bahadur Shastri National Academy of Administration where officers are trained for the Indian Administrative Service and the Indian Police Service. Enroute visit - <br />
Rishikesh: was named after the God Hrishikesh whose appearance is an answer to the lord penances by Rabhiya Rishi. The Holy Chardham yatra has its starting point from Rishikesh. Rishikesh is a famous Hindu religious destinations, popular amongst devotees, yoga persons and adventurers as well. Located on the banks of the sacred Ganga River, Rishikesh attracts thousands of pilgrims every day from India as well as abroad. covering Lakshman Jhula ,Gita Bhavan, Neelkanth Mahadev temple etc. <br />
Arrival at Mussoorie transfer to hotel ,check in to hotel ,Rest of the day is free for leisure or explore various scenic sights or visit mall road. overnight stay at hotel at Mussoorie.</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> Mussoorie
								</p>
								<p class="aj">After breakfast, visit to Kempty fall, kempty fall, municipal garden,Gun hill,  Company Garden, Mall road etc. <br />
Lal Tibba : This is regarded as the highest point in Mussoorie situated in area called “Landour”. Which is know to be the oldest inhabited place of Mussoorie<br />
Gun Hill : Gun hiil is the second highest point in Mussoorie.it is also known as picnic spot for the locals.From this points,Mussoorie appears to be changing colors in every minute.It looks amazing from here.<br />
Municipal Garden : This is also known as Botanical Gardens of Mussoorie were established by geologist Dr. H.Fackner in the last century.<br />
Kempty Fall : Kempty fall is just 12 kms down from Mussoorie on Mussoorie - Dehradun midway ,the beautifull falls were declared as a tourist destination by John Mekinan after after 1835.The name Kempty is derived from 'Camp - tea', as the Britishers would organise their tea parties here. Past Kempty Fall, 12 - km downhill. Later back to hotel,free for leisure.overnight stay at hotel at Mussoorie</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> Mussoorie - Ranikhet (380kms - 8hrs)
								</p>
								<p class="aj">After breakfast check out from hotel then drive to Ranikhet. <br />
Ranikhet: The salubrious atmosphere, tall conifer trees, green meadows and placid surroundings makes Ranikhet a unique hill station. The magnetism of each season in Ranikhet is always capable of luring tourists, making it an all season destination. The majestic Himalayas, lush green forests, sounds and smell of the flora and fauna leaves an unforgettable impact on the visitors.  worth watching excursions, ancient temples, fascinating picnic spots and exciting treks. Ranikhet also headquarters one of the glorious regiment of Indian Army - Kumaon Regiment.Ranikhet literally means “Queen's Meadow”. It is believed that Queen Padmini of Kumaon was in love with this tiny hill paradise. Kind Sudhardev had to oblige her by building a palace here and named this place Ranikhet, the queen’s field. <br />
Arrive at ranikhet transfer to hotel, check in to hotel, rest of the day is for a leisurely walks of this gorgeous town of Ranikhet. Overnight stay at hotel at Ranikhet.</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> Ranikhet - Kausani - Ranikhet (60kms -1.30hrs)
								</p>
								<p class="aj">After breakfast excursion to Kausani.<br />
Kausani: nature own reserve and idle to spend a quiet holiday in the lap of nature with stunning view of the Himalayan ranges. Mahatma Gandhi, during his stay at Kausani, penned his memorable commentary on the 'Gita-Anashakti Yoga' inspired by the scenic grandeur of this richly gifted spot. Mahatma Gandhi was so much impresses that he started calling it “Switzerland of India”. The guesthouse where Mahatma Gandhi stayed is now known as the Anashakti Ashram. Famous Hindi poet Sumitra Nandan Pant was born at Kausani. Some of her early poems composed here have described the nature in its manifestations. Afternoon picnic near the River Kosi and day to explore the beauty of nature. Evening return to Ranikhet. overnight stay at hotel at Ranikhet</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> Ranikhet - Nainital (70 kms - 2 hrs).
								</p>
								<p class="aj">After breakfast checkout from hotel then drive to Nainital.<br />
Nainital : is referred to as the lake of three sages, or the Tri Rishi Sarovar as mentioned in the Manas Khand chapter of the Skanda Purana. As recorded in history, the three sages, Atri, Pulastya, and Pulaha stopped over at Nainital on their pilgrimage, to quench their thirst. Finding no water, they dug a hole and transferred some water into it to from the sacred lake of Tibet, Mansarovar. Thus the famous lake of Nainital came into existence. Another legend has it that the left eye or Nain of Lord Shiva’s wife Sati fell in this center and formed an emerald eye shaped lake, and thus emerged the city of Nainital.Recent history records reveal that Nainital was brought into limelight by P. Barron, a British sugar merchant, in 1839. The beauty of Nainital with the central lake cushioned among the forests attracted this person to build a house named Pilgrim’s Cottage and settle in Nainital.<br />
Arrive at Nainital transfer to hotel, Check in to hotel .Evening you will walk to Naini Lake and Mall road. Rest of the day free at leisure.Overnight stay at hotel at Nainital.</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> Nainital
								</p>
								<p class="aj">After breakfast, Full day is at leisure to explore the hill retreat of Nainital. It is blessed with scenic natural splendour and varied natural resources . visit to lakes tour of Bhim Tal, Sat Tal, Naukuchia Tal , Snow point,thandisarak, cable car & Mall road. Later back to hotel, Rest of the day free at leisure ,overnight stay at hotel at  Nainital.</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> Nainital - Delhi(320kms - 7- 8hrs)
								</p>
								<p class="aj">After breakfast check out from hotel then drive to Delhi. Arrive at Delhi and transfer to airport/railway station for onward destination.</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>
																		<li>Transfers</li>
															</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Any Airfare, Train Fare, Overland Journey Which Is Not Mentioned In The Itinerary.</li><li>
Any Personal Nature Items Like Laundry, Bar Bills, Table Bills, Camera Fee, Tips Or Any Other Item.</li><li>
Guide / Entry Fees / Boatings /Horse Ridings Etc. During Sight Seeings</li><li>
Any Medical /Rescue Evacuation Due To Mishaps. </li><li>
Optional Activities Mentioned In The Itinerary </li><li>
Any Other Things That Is Not Included In The “Package Cost Includes” Column.<br><br>Note:</li><li>
Any Changes In Govt. Taxes, Hotel Tariff, Etc Will Be Intimated Before Confirming The Package. </li><li>
Cost Incidental To Any Change In The Itinerary/ Stay On Account Of Flight Cancellation Due To Bad Weather, Ill Health, Roadblocks And/Or Any Factors Beyond Control. </li><li>
Government Service Tax @ 3.09 Extra </li><li>
Every Passenger Is Traveling On His Own Responsibility. The Company Will Not Be Responsible For Any Loss Of Luggage Or Any Accidents. We Are Not Responsible For Theft Or Damage To Your Luggage.</li><li>
Also Note That Video & Audio Systems Are Prohibited In Commercial Vehicles As Per Law And We Do Not Guarantee For It Always.</li></ul><br />
												</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.chaturveditravels.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Fabulous Uttarakhand 08Night-09 Days 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="27860"/>
						</form>
						</div>
						
						";i:1;s:80:"Book Fabulous Uttarakhand 08Night-09 Days Tour - 8 Nights / 9 Days Tour Packages";i:2;s:168:"book fabulous uttarakhand 08night-09 days tour - 8 nights / 9 days tour packages, valley tour packages, new delhi, mussoorie, haridwar, nainital, ranikhet tour packages";i:3;s:213:"Chaturvedi Travels and Tours offers Fabulous Uttarakhand 08Night-09 Days Tour - 8 Nights / 9 Days tour package, budget Valley tour packages for New Delhi, Mussoorie, Haridwar, Nainital, Ranikhet at exciting price.";i:4;s:1534:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "New Delhi, Mussoorie, Haridwar, Nainital, Ranikhet"        
		                 },
		      "description": "Any Airfare, Train Fare, Overland Journey Which Is Not Mentioned In The Itinerary.
Any Personal Nature Items Like Laundry, Bar Bills, Table Bills, Camera Fee, Tips Or Any Other Item.
Guide / Entry Fees / Boatings /Horse Ridings Etc. During Sight Seeings
Any Medical /Rescue Evacuation Due To Mishaps. 
Optional Activities Mentioned In The Itinerary 
Any Other Things That Is Not Included In The “Package Cost Includes” Column.<br><br>Note:
Any Changes In Govt. Taxes, Hotel Tariff, Etc Will Be Intimated Before Confirming The Package. 
Cost Incidental To Any Change In The Itinerary/ Stay On Account Of Flight Cancellation Due To Bad Weather, Ill Health, Roadblocks And/Or Any Factors Beyond Control. 
Government Service Tax @ 3.09 Extra 
Every Passenger Is Traveling On His Own Responsibility. The Company Will Not Be Responsible For Any Loss Of Luggage Or Any Accidents. We Are Not Responsible For Theft Or Damage To Your Luggage.
Also Note That Video & Audio Systems Are Prohibited In Commercial Vehicles As Per Law And We Do Not Guarantee For It Always.",
		      "name": "Fabulous Uttarakhand 08Night-09 Days Tour",
		      "telephone": "+91-9826355115"
		    }
		    </script>
			";i:5;N;}