a:6:{i:0;s:15746:"				<div class="h1"><h1>DARJEELING TOUR - QUEEN OF HILLS</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.sunbirdjourney.in/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.sunbirdjourney.in/tour-packages.htm" title="Tour Packages">Tour Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>DARJEELING TOUR - QUEEN OF HILLS</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">SBJ.T.0004</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Duration </td>
						<td class="p5px pl0px vat">
						3 Nights / 4 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 6000 Per Person						</td>
						</tr>
												<tr>
						<td class="b p5px dif w125px vat">Special Offer </td>
						<td class="p5px pl0px dif vat">Price valid for minimum 06 adult travelling together<br />
Contact for best group rate</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.sunbirdjourney.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="DARJEELING TOUR - QUEEN OF HILLS - 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="51033"/>
						</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_13/377396/100342.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/100342.jpg"  width="150" height="150"    alt="Queen of Hills" title="Queen of Hills" /></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_13/377396/146632.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/146632.jpg"  width="150" height="150"    alt="DARJEELING TOUR - QUEEN OF HILLS" title="DARJEELING TOUR - QUEEN OF HILLS" /></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_13/377396/146633.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/146633.jpg"  width="150" height="150"    alt="DARJEELING TOUR - QUEEN OF HILLS" title="DARJEELING TOUR - QUEEN OF HILLS" /></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_13/377396/146634.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/146634.jpg"  width="150" height="150"    alt="DARJEELING TOUR - QUEEN OF HILLS" title="DARJEELING TOUR - QUEEN OF HILLS" /></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_13/377396/146635.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/146635.jpg"  width="150" height="150"    alt="DARJEELING TOUR - QUEEN OF HILLS" title="DARJEELING TOUR - QUEEN OF HILLS" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					Darjeeling, Originally just a cluster of villages that was administered intermittently by Nepal and Sikkim, Darjeeling grew in prominence during the mid 19th century when, because of its climate, the British first established a hill station there after leasing it from the Chogyal of Sikkim and later discovered that the area was particularly well suited for tea plantations. In 1849, the British annexed the area and Darjeeling became a part of British India. The Darjeeling Himalayan Railway was opened in 1881 (it is now a UNESCO World Heritage Site) and the town became the de-facto summer capital of India during the days when the Raj was governed from Calcutta.<br />
Because it was a popular hill station during the days of the Raj, a lovely Victorian town was built among the Himalayan foothills, the remnants of which are still visible around the Chowrasta and Darjeeling remains a popular summer and fall resort for the natives of Kolkata today. For foreign tourists, the main attractions are the cultural diversity (many Tibetan refugees moved here after Tibet was annexed by China and they co-exist with the descendants of the many Nepali and Bihari laborers brought to work in the tea plantations), the beautiful views (including the wonderful vista view of Kanchenjunga), a variety of trekking options, and the opportunity to cool down after a stint in the plains. The town is also a jumping off point for travelers heading to Sikkim. 4 Days Sightseeing in Darjeeling. There has been intermittent political action from Gorkha groups demanding an independent state (Gorkhaland). In June 2008 a strike paralyzed the area, with closed hotels, restaurants and shops, and the accompanying protests even turned violent a couple of times. Though inconvenient, tourists generally are not at risk, but recently they do check the status before going there.<br />
<br />
The nearest airport is Bagdogra, near Siliguri, 96 km from Darjeeling. Bagdogra Airport is 2.5 hours by road from Darjeeling and 2 hours by air from Delhi, and 50 minutes by air from Kolkata.<br />
<br />
The nearest railway station to Darjeeling is New Jalpaiguri which connects the city with all the major parts of the country. There are a number of trains from cities like Kolkata, Delhi, Guwahati, Chennai, Mumbai, Bengaluru, Bhubaneshwar and Kochi.Price valid for minimum 06 adult travelling together<br />
Contact for best group rateGovt Service Tax. as applicable<br />
Room incidentals.<br />
Lunch during the tour<br />
Horse ride/pony ride/helicopter ticket<br />
Tipping/gratuities to guide/driver.<br />
Beverages during meal time.<br />
All entrance fees where ever applicable.<br />
Camera & Video permits. <br />
Any services not mentioned in the above.19-0120-12<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 NJP/bagdogra - Darjeeling via Mirik
								</p>
								<p class="aj">Upon arrival at Bagdogra airpot/Newjalpaiguri railway station , Meet our representive& transfer to Darjeeling at an elevation of 2125 meters / 70000 feet, the land of breathtaking beauty, amidst rolling tea gardens, crowned by the majestic Himalayas popularly known as the Queen of the hills. Jewel in the crown of the Eastern Himalayas with mesmerizing beauty offers spectacular views of the Mount Everest, Mount Kanchendzonga and the rest of spectacular Himalayan range. Sightseeing at Mirik. Check - in at hotel / resort at Darjeeling. Evening free to roam around in Mall. Overnight stay at Darjeeling.</p>					
									<p><b>Meals : </b> Dinner</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_13/377396/146632.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/146632.jpg"  width="150" height="150"    alt="DARJEELING TOUR - QUEEN OF HILLS" title="DARJEELING TOUR - QUEEN OF HILLS" /></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> Darjeeling Best points Sightseeing
								</p>
								<p class="aj">Early morning start for Tiger Hill to watch the spectacular sunrise and its amazing effects on the Mt. Kanchendzonga   (Worlds 3rd highest peak), Visit Ghoom Monastery and Batashia Loop War Memorial while returning to the Hotel. After breakfast followed by Half day best point local sightseeing covering Japanese Temple, Peace Pagoda, Padmaja N. Zoological Garden, Himalayan Mountaineering Institute, Tibetan Refugee Self-help Center and Rock side. After that visit to the Mall (Chowrasta) along with local Market for City Life. Overnight at hotel.</p>					
									<p><b>Meals : </b> Breakfast & Dinner</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_13/377396/146633.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/146633.jpg"  width="150" height="150"    alt="DARJEELING TOUR - QUEEN OF HILLS" title="DARJEELING TOUR - QUEEN OF HILLS" /></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> Darjeeling
								</p>
								<p class="aj">Breakfastat hotel. full day free at leisure, enjoy the nature view of Himalaya - Evening free to roam around the any of the hundred nurseries or the Local market area - Overnight stay at hotel in Darjeeling</p>					
									<p><b>Meals : </b> Breakfast & Dinner</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_13/377396/146634.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/146634.jpg"  width="150" height="150"    alt="DARJEELING TOUR - QUEEN OF HILLS" title="DARJEELING TOUR - QUEEN OF HILLS" /></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 4:</b> Depart from Darjeeling
								</p>
								<p class="aj">After breakfast check out from hotel and transfer to Newjalpaiguri railway station / Bagdogra airport.<br />
Depart by train/flight with Sweet Himalayan memory………</p>					
									<p><b>Meals : </b> Breakfast</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_13/377396/146635.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/146635.jpg"  width="150" height="150"    alt="DARJEELING TOUR - QUEEN OF HILLS" title="DARJEELING TOUR - QUEEN OF HILLS" /></a></p></div></li>
									</ul>
									</div>
									</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>Meals</li>
																		<li>Sightseeing</li>
																		<li>Transport</li>
																		<li>Transfers</li>
															</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Govt Service Tax. as applicable</li><li>
Room incidentals.</li><li>
Lunch during the tour</li><li>
Horse ride/pony ride/helicopter ticket</li><li>
Tipping/gratuities to guide/driver.</li><li>
Beverages during meal time.</li><li>
All entrance fees where ever applicable.</li><li>
Camera & Video permits. </li><li>
Any services not mentioned in the above.</li></ul><br />
												<p class="large b mb5px dif">Specific Departure Dates :</p>Any date<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.sunbirdjourney.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="DARJEELING TOUR - QUEEN OF HILLS - 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="51033"/>
						</form>
						</div>
						
						";i:1;s:71:"Book DARJEELING TOUR - QUEEN OF HILLS - 3 Nights / 4 Days Tour Packages";i:2;s:127:"book darjeeling tour - queen of hills - 3 nights / 4 days tour packages, lakes & rivers tour packages, darjeeling tour packages";i:3;s:159:"Sunbird Journey offers DARJEELING TOUR - QUEEN OF HILLS - 3 Nights / 4 Days tour package, budget Lakes & Rivers tour packages for Darjeeling at exciting price.";i:4;s:3095:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Darjeeling"        
		                 },
		      "description": "Darjeeling, Originally just a cluster of villages that was administered intermittently by Nepal and Sikkim, Darjeeling grew in prominence during the mid 19th century when, because of its climate, the British first established a hill station there after leasing it from the Chogyal of Sikkim and later discovered that the area was particularly well suited for tea plantations. In 1849, the British annexed the area and Darjeeling became a part of British India. The Darjeeling Himalayan Railway was opened in 1881 (it is now a UNESCO World Heritage Site) and the town became the de-facto summer capital of India during the days when the Raj was governed from Calcutta.
Because it was a popular hill station during the days of the Raj, a lovely Victorian town was built among the Himalayan foothills, the remnants of which are still visible around the Chowrasta and Darjeeling remains a popular summer and fall resort for the natives of Kolkata today. For foreign tourists, the main attractions are the cultural diversity (many Tibetan refugees moved here after Tibet was annexed by China and they co-exist with the descendants of the many Nepali and Bihari laborers brought to work in the tea plantations), the beautiful views (including the wonderful vista view of Kanchenjunga), a variety of trekking options, and the opportunity to cool down after a stint in the plains. The town is also a jumping off point for travelers heading to Sikkim. 4 Days Sightseeing in Darjeeling. There has been intermittent political action from Gorkha groups demanding an independent state (Gorkhaland). In June 2008 a strike paralyzed the area, with closed hotels, restaurants and shops, and the accompanying protests even turned violent a couple of times. Though inconvenient, tourists generally are not at risk, but recently they do check the status before going there.

The nearest airport is Bagdogra, near Siliguri, 96 km from Darjeeling. Bagdogra Airport is 2.5 hours by road from Darjeeling and 2 hours by air from Delhi, and 50 minutes by air from Kolkata.

The nearest railway station to Darjeeling is New Jalpaiguri which connects the city with all the major parts of the country. There are a number of trains from cities like Kolkata, Delhi, Guwahati, Chennai, Mumbai, Bengaluru, Bhubaneshwar and Kochi.Price valid for minimum 06 adult travelling together
Contact for best group rateGovt Service Tax. as applicable
Room incidentals.
Lunch during the tour
Horse ride/pony ride/helicopter ticket
Tipping/gratuities to guide/driver.
Beverages during meal time.
All entrance fees where ever applicable.
Camera & Video permits. 
Any services not mentioned in the above.19-0120-12",
		      "name": "DARJEELING TOUR - QUEEN OF HILLS",
		      "telephone": "91-9038012283"
		    }
		    </script>
			";i:5;N;}