a:6:{i:0;s:18178:"				<div class="h1"><h1>Northeast Honeymoon Package</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.mydreamtriip.com/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.mydreamtriip.com/travel-packages.htm" title="Travel Packages">Travel Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Northeast Honeymoon Package</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">
						7 Nights / 8 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Gangtok, Darjeeling, Kalimpong</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat"><span class="dif">On Request</span></td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.mydreamtriip.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Northeast Honeymoon Package - 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="85410"/>
						</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_13/372792/150063.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/372792/150063.jpg"  width="150" height="150"    alt="Northeast Honeymoon Package" title="Northeast Honeymoon Package" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<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> Arrival in Siliguri -Transfer to Darjeeling
								</p>
								<p class="aj">Arrive in Siliguri at New Jalpaiguri Railway Station (68 km) / Bagdogra Airport (69 km) / Tenzing Norgay Bus Stand (62 km), met our tour representative. He would help you in taking an assisted transfer to Darjeeling.<br />
<br />
Home to the World Heritage Train- the Darjeeling Himalayan Railway (DHR) or the toy train, Darjeeling is an enchanting hill station. Lying at a height of 7100 feet above the sea level, Darjeeling has aromatic lush tea estates, tranquility in abundance, breathtaking scenery, Buddhist monasteries, bustling streets and several striking views.<br />
<br />
After you arrive in Darjeeling, check- into the hotel. You can relax for a while. The evening is at leisure and you can spend it as per your own liking. Have a leisure walk up to the Mall or visit the local shopping centers to get your hands on some memorabilia. Over Night stay at Darjeeling</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> Darjeeling sightseeing
								</p>
								<p class="aj">Day 2 starts quite early. Get-up around 3:45 AM to drive towards Tiger Hill (11 km) to view sunrise over the Kanchendzonga Peak (subject to clear weather). One of the major attractions in Darjeeling, the route taking to you the hill, amid Oak forests, is an extremely refreshing one. It is advisable to start early top save yourself from traffic snarls up the hill. When the sun rises behind from the hill, it illuminates the Peak and looks like an orange-colored ball. Treat your eyes to the scenery and soak-in the tranquility.<br />
<br />
On your way back, visit Ghoom Monastery- also called Yiga Choeling monastery, it is one of Darjeeling’s oldest gompas. Belonging to the Yellow sect of Buddhism, the construction of this monastery started in 1850. The statue of Maitreya Buddha, Lord Buddha of the future is the main attraction here. Next attraction is the War memorial, lying in the well-maintained garden, bounded by Batasia Loop. The memorial is built in the memory of Gorkha martyrs who sacrificed their lives in the wars to save their country. You can also opt for a ride in the toy train on the loop, offering enchanting landscape views.<br />
<br />
Return to the hotel for breakfast and start the second leg of sightseeing including Padmaja Naidu Himalayann Zoological Park, Himalayan Mountaineering Institute (Closed on Thursday), Ropeway, Tensing Gumpo Rock, Tibetan Refugee Self Help Center (Closed on Sunday), Tea Estate, Natural History Museum (Sunday Closed), Peace Pagoda<br />
<br />
Padmaja Naidu Himalayann Zoological Park- Known all around the globe, it is popular for its conservation breeding programs of Red Panda, Tibetan Wolf, Snow Leopards and other endangered animal species of the Eastern Himalaya. Take a walk in the sprawling Tea estates to soak-in the serenity and refreshing aroma. The sight of greenery spread all around looks quite soothing. The Cable car ride on Darjeeling Ropeway offers spectacular views Rangeet Valley. The white colored Peace-pagoda is a huge dome-like structure is another attraction here that has golden-colored Buddha statues in varied postures.<br />
<br />
Overnight stay in Darjeeling</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> A day’s visit to Mirik (58 km- 1 hr 30 min)
								</p>
								<p class="aj">The day after breakfast is for a day’s trip to Mirik. Perched at an elevation of 1494 m above the sea level, Mirik is an off-beat destination that is becoming a popular tourist destination, near Darjeeling. The drive from Darjeeling to Mirik has a few scenic spots from where you can stop for photo opportunity. With Sumendu Lake in its mid-point, beautiful Mirik town is blessed with verdant tea gardens, landscaped gardens, cardamom groves and the mighty Himalayas. Spend the day here, indulging in activities like boating in Sumendu Lake and horse riding to explore the place.<br />
<br />
In the evening, back to Darjeeling. On your way back, taka a stoppage at Pashupati Market (on the India-Nepal Border). You can get your hands on antiques, souvenirs, foreign goods and other knick-knacks.<br />
<br />
in Darjeeling, the evening is free for visiting the Mall Road or the Local market area.<br />
<br />
Overnight in Darjeeling.</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> Darjeeling- Kalimpong (49 km- 1 hr 40 min) (Sightseeing)
								</p>
								<p class="aj">Start your day with an early morning breakfast. Check-out formalities, followed by transfer to Kalimpong. Placed at the foothills of the Himalayas, the lush destination of Kalimpong is located at an altitude of 1250 meters above the sea level.<br />
<br />
Offering a relaxed ambiance for a peaceful retreat, Kalimpong boasts of some of the most striking views of the Himalayan peaks. This bustling town has colonial-style architecture and Buddhist monasteries. The serenity spread all around the place attracts the tourists from all around. On arrival, complete the check-in formalities at the hotel.<br />
<br />
Leave the hotel room to begin sightseeing in Kalimpong including the popular attractions such as Forest Museum (Closed On Thursday), Deolo Hill, Hanuman Mandir- a Hindu temple with a huge statue of Lord Hanuman that is near Durga temple, Dr Graham Homes, Durpin Monastery, Mangal Dham- another beautiful tranquil temple complex in Kalimpong that has temples of Lord Krishna and Guru Mangal Das Ji, Pine View Nurseries (Cactus Only)<br />
<br />
Located on Durpin hill (1372 m), Durpin Gompa boasts of being the largest monastery of Kalimpong, formally known as Zangtok Pelri Phodang. Dalai Lama, in the year 1976, had consecrated this monastery. The Gompa is 5 km southwards of the town. When inside the monastery, do not miss the attractive religious murals. From the monastery’s terrace, enjoy nice views of Khangchendzonga. Started in 1900, by Dr JA Graham- a Scottish missionary, Dr Graham Homes is a school and an orphanage that co-educates children of the workers in tea-estates. The school structure is Scottish in architecture and the premise has a museum too. Once you get on the top of Deolo Hill, treat your eyes to the mesmerizing views of the Kanchenjunga, the world’s third highest mountain and the town. There is a well-maintained park too. Pony rides are offered for kids.<br />
<br />
Stay overnight in Kalimpong.</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> Kalimpong- Gangtok (73.5 km- 2 hrs)
								</p>
								<p class="aj">Today, have your breakfast and begin driving towards Gangtok, the capital city of the north-eastern state of Sikkim.<br />
<br />
Located at an elevation of 1600 meters above the sea level, the beautiful and peaceful hill town of Gangtok, is known to be one of the most popular tourist destinations of North-eastern region of the country. Its Buddhist monasteries, abundant lush scenery and pleasant climate allure honeymooners from all around. Hold hands in hands and admire the enchanting scenery of the town. Gangtok also houses a vast variety of butterflies, and colorful flowers like Orchids and Rhododendron.<br />
<br />
On arrival, complete the check-in formalities at the hotel. Now you can rest for a while. The evening is at leisure. If you want, you can visit the very popular M G Road (Mall) to indulge in shopping and collecting memorabilia. Get your hands on woolen clothes, Thangka paintings, handicrafts and more. Overnight stay in Gangtok</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> Gangtok sightseeing
								</p>
								<p class="aj">The sixth day of the itinerary is for visiting the popular attractions of Gangtok, after morning breakfast Visit to Directorate of Handicrafts & Handloom, Research Institute of Tibetology, Do Drul Chorten (Stupa), Enchey Monastery, White Hall, Flower Show, Ganesh Tok- a temple dedicated to Lord Ganesha, placed on a small hill on the Gangtok-Nathula Road, Hanuman Tok, Tashi View Point, Banjhakri Falls, one of the finest falls close to Gangtok, place amidst a lush green well-maintained Shamanistic- themed park.<br />
<br />
One of Sikkim’s most renowned temples, Hanuman Tok is dedicated to Lord Hanuman. The temple complex is well taken care of by the Indian Army. As the temple is placed on high altitudes, the complex offers wonderful opportunities for photography as the views of the peaks are stunning from here.<br />
<br />
Probably the biggest stupa of Sikkim, Do Drul Chorten is located on a hill. This sacred spot was built in the year 1945 by Late Truslshi Rimpoche, the head of Nyingma sect of Tibetan Buddhism. The golden-colored dome is the highlight of the structure. You can spot lamas engrossed in their prayers.<br />
<br />
Founded in the year 1909, Enchey Monastery is one of the Gangtok’s most popular Gompas. Placed on a hill, the monastery offers exciting views of Mt Kanchenjunga. The structure of the monastery is inspired from a Chinese Pagoda and the images of deities adorn the inner walls. Spot the statues of Guru Rinpoche and Lord Buddha, who are worshipped here.<br />
<br />
If you are a nature lover, do visit the permanent flower show held at the Flower Exhibition Center, another popular attraction. The floral exhibition site is near Ride Park and White Hall, and is a place where you must not miss clicking photographs. This exhibition area has a green house effect and consists of a vast variety of floral species such as celosia, gerberas, roses, orchids and more.<br />
<br />
During the night hours, you can visit the discotheques in Gangtok. Stay overnight.</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> Day’s trip to Tsomgo Lake and Baba Mandir
								</p>
								<p class="aj">Day 7 of the tour is for visiting the nearby attractions of Gangtok. The day is scheduled for excursion to Tsomgo Lake and Baba Mandir. Have your breakfast and leave for your trip.<br />
<br />
Tsomgo Lake or Changu Lake, lying at an elevation of 12,400 feet above the sea level is a glacial lake, which is 37 km away from Gangtok. This stunning attraction, it is frequently visited by Brahmin ducks and other colorful migratory birds. This oval-shaped lake is 50 feet deep and is covered with snow all round the year. Let your kids can yak rides; there are shops near the lake selling Yak cheese. On the banks of the Lake, there is a temple also, dedicate to Lord Shiva temple. Capture the beautiful scenery through your camera.<br />
<br />
After exploring the Lake site, continue towards the next attraction of the day Baba Harbhajan Singh Memorial War temple, around 20 km from here. Originally a war memorial, built in the memory of soldier Harbhajan Singh of the 23rd Punjab Regiment, who sacrificed his life in the Indo-China was of year 1962, it slowly turned into a temple. It was constructed in 1983 by the Indian Army after the deceased soldier appeared in the dream of his soldier friend. This temple made inside the bunker of the soldier and consists of his personal belongings like photographs. There is a wishing pond near the temple. Throw a coin in the pond and make a wish.<br />
<br />
In the evening, return to Gangtok. If time permits, you can visit the Mall Road or simply relax in your room. (Note- If there is landslide or we are not able to take you to Tsomgo Lake, there will be an alternate sightseeing).</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> Gangtok to Siliguri for departure– Siliguri / New Jalpaiguri Railway Station (119) / Bagdogra Airp
								</p>
								<p class="aj">On the last day of the tour, after breakfast get on-time transfer to Siliguri -New Jalpaiguri Railway Station / Bagdogra Airport / Tenzing Norgay Bus Stand for your onward journey.</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>
															</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.mydreamtriip.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Northeast Honeymoon Package - 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="85410"/>
						</form>
						</div>
						
						";i:1;s:66:"Book Northeast Honeymoon Package - 7 Nights / 8 Days Tour Packages";i:2;s:134:"book northeast honeymoon package - 7 nights / 8 days tour packages, valley tour packages, gangtok, darjeeling, kalimpong tour packages";i:3;s:165:"My Dream Triip offers Northeast Honeymoon Package - 7 Nights / 8 Days tour package, budget Valley tour packages for Gangtok, Darjeeling, Kalimpong at exciting price.";i:4;s:439:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Gangtok, Darjeeling, Kalimpong"        
		                 },
		      "description": "",
		      "name": "Northeast Honeymoon Package",
		      "telephone": "91-9987586414/9892943660"
		    }
		    </script>
			";i:5;N;}