a:6:{i:0;s:20440:"				<div class="h1"><h1>Delightful North East with Pelling Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.journey99.com/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.journey99.com/packages.htm" title="Holiday Packages">Holiday Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Delightful North East with Pelling 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">
						6 Nights / 7 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Gangtok, Darjeeling, West Sikkim</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.journey99.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Delightful North East with Pelling 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="76469"/>
						</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_12/354567/135683.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_12/354567/135683.jpg"  width="150" height="150"    alt="Delightful North East with Pelling Tour" title="Delightful North East with Pelling Tour" /></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 Darjeeling
								</p>
								<p class="aj">The amazing tour starts with your arrival at New Jalpaiguri Station (NJP), Bagdogra airport (IXB) and Tenzing Norgay Bus Stand (Junction) in West Bengal. From here, you need to travel to Darjeeling, which is on the northern extreme of the state. Once you arrive, our tour representative will escort you to the hill station of Darjeeling via road. The beautiful hill station of Darjeeling resides at an altitude of 7100 ft in West Bengal, and is 68 km from NJP Railway Station, 69 km from Bagdogra airport and 65 km From the Tenzing Norgay Bus stand.<br />
<br />
Surrounded by the snow capped peaks of Kanchenjunga, Darjeeling is amongst the most popular tourist attractions in this part of India. The beauty of the hill station can be defined by its lush green tea plantations, which are known to be the best in the world, its rolling hills and alpine forests. Besides the acres of tea estates, Darjeeling is also known for its monasteries and various town attractions. Other than the natural attractions, Darjeeling is also known for its quaint colonial charm, like the centuries old world heritage Darjeeling Himalayan Railway system.<br />
<br />
As you reach Darjeeling, check in to our pre booked hotel. Spend your evenings at leisure in the hotel and if you wish to move out, feel free to roam around local shopping centers.</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 local sightseeing
								</p>
								<p class="aj">Start your day as early as 3:45 AM, by heading towards Tiger Hill, which is around 11 km from the main town of Darjeeling. Tiger Hill is one of the main attractions in Darjeeling and can be reached on foot easily, all along the splendid tea plantations. The top of the hill overlooks the highest peak in Sikkim, Mt. Kanchenjunga, and if the weather is clear, Mt. Everest also. Its claim to fame has been its view of the sunrise. When rays of the morning sun fall on Mt. Kanchenjunga it illuminates the mountain, giving it a golden orange reflection and thus offering a breathtaking sight.<br />
<br />
On your way back, make a visit to the some of the most popular attractions in Darjeeling. Starting from Ghoom monastery, then War Memorial and finally, Batasia Loop.<br />
<br />
Just 8 km short of Darjeeling, you will come across Ghoom Monastery, which lies at an elevation of around 7400 feet. Ghoom Monastery was supposed to be built in the year 1850 by Lama Sherab Gyatso. The renowned monastery belongs to the Yellow Hat Sect, known as Gelupka. Once inside the monastery, you will come across a 15 foot model of Lord Buddha, which is also called as Maitreya Buddha. In Buddhism, Maiteya Buddha means Buddha of the future or the coming Buddha. Interesting fact about the statue of Maitreya Buddha is that it is all made up of clay, all imported from Tibet. Besides the statue of Buddha, the monastery is also famous for housing a huge collection of Buddhist manuscripts.<br />
<br />
Post the monastery, hop on to the vintage Toy train as it makes its way through the exotic landscapes in Darjeeling. The toy train also whistles away through the magnificent Batasia Loop, which makes its curve at the Hill Cart road. The loop has a colorful garden of exotic flowers built in the inner circle of the loop. From the Batasia Loop, you can have a wholesome view of the enchanting Darjeeling valley along with the snow capped peaks of Kanchenjunga.<br />
<br />
Right in the middle of the Batasia Loop, lies the War Memorial. As evident from its name, the structure was built in honor of numerous Gorkha soldiers, who lost their lives in military operations since India’s independence. Truly an amazing attraction, the War Memorial is amongst the prominent ones in Darjeeling.<br />
<br />
After these visits, return back to your hotel for breakfast. Nearly half an hour later, you would be embarking on a sightseeing trip to attractions in the main town of Darjeeling. This includes visits to Himalayan Montaineering Institute, Tensing Gumpo Rock, Padmaju Naidu Zoological Park, Tibetan Refugee Self Help Cente and Natural History Museum.<br />
<br />
Finish your day on a peaceful note by visiting the heritage of world peace, Japanese Peace Pagoda, which is located in the vicinity of other attractions. The Peace Pagoda showcases four avatars or forms of Lord Buddha and focuses on uniting people of all communities for world peace. Pay your visits there and return back to your hotel for an overnight stay. Evenings are meant to explore the local surroundings or shopping in the nearby markets, although you can even choose to stay indoors and rest.</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> Transfer to Pelling
								</p>
								<p class="aj">Post breakfast, you would be transferred to Pelling, which is located in the western part of Sikkim. Highly appreciated for its natural vistas and serenity, Pelling in Sikkim is a prominent hill station in the northeast of India. Situated at an altitude of around 6800 ft, the hill station offers a panoramic view of the highest peak in Sikkim, Mt. Kanchenjunga. Not just Kanchenjuga, the place offers a kaleidoscope of mountain peaks, like Kanchenjunga, Rathong, Koktang, Pandim, Sinlolchu and Kumbhakaran. Besides the lofty mountain peaks, beauty of this hill station lies in its lush green alpine and Rhododendron forests that are perfect for nature trails. The region is also a home of some of the rarest species of Himalayan animals. Kanchendzonga National Park in this part of Sikkim provides a natural habitat to them. Amidst all the greenery, lies some magnificent waterfalls, which are counted amongst the perfect natural spots to wind up with family and friends.<br />
<br />
The drive from Darjeeling to Pelling is likely to take around 1 hour and 55 mins. As you reach the hill station, make a check in to an already booked hotel for an overnight stay. Rest of the day would be at leisure. You can choose to relax in your rooms or move out for a stroll in the nearby market places.</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> Pelling local sightseeing
								</p>
								<p class="aj">Fourth day of our exclusive tour is dedicated to sightseeing in and around Pelling. What better way than remembering the Lord in your heart to start the day. Owing to this, you will be heading to Pemayangtse monastery at the first place.<br />
<br />
About 2km from the main town of Pelling, lies the principal monastery of Ngingma sect, Pemayangtse Monastery. This Buddhist pilgrimage center is said to be built in the year 1705, by Gyalwa Lhatsun Namkha Jigme. The decorated monastery is like an epicenter of all the other Nyingma monasteries and is believed to maintain the order of this sect. Being hit by earthquakes twice, the structure of Pemayangtse monastery underwent several renovations.<br />
<br />
At present, the floors of the monastery are decorated with paintings, sculptures and ancient scriptures. Besides the paintings and sculptures, you will come across eight incarnations of Padmasambhava, in the form of statues, which look highly stunning. The center of attraction remains the main statue of Padmasambhava, which represents Tantric form of Buddhism. As you would be done with the monastery, embark on a nature trip to places like Kecheoplari lake, Rimbi waterfalls, Rimbi rock garden and Kanchenjunga falls.<br />
<br />
Located 27 km from the town of Pelling, Khecheoplari lake is amongst the most sacred lakes of Sikkim. Journey to the sacred lake would take you right across a thick forest cover. The lake is beautiful, placid and clean to explore.<br />
<br />
Just a km ahead, at a sharp curve on the road side, lies the wonderful Kanchenjunga falls. Owing to its beauty and grandeur, the waterfalls are amongst the prominent attractions in Darjeeling. The waterfall is perennial and it gets its source from glaciers high up in the mountains. There are also numerous shops and stalls established in the vicinity of the falls. You can have a nice cup of coffee amidst the wonderful surroundings of the Kanchenjunga falls.<br />
<br />
Rimbi Rock Garden or Sewaro Rock Garden is an attraction of gardens, pools and zigzag foot paths. Situated around 12 km from the main town of Pelling, the rock garden is a perfect place to wind up for a picnic. As you move 5 km from here, you will come face to face with Rimbi waterfalls, which is breathtaking to every eyeball.<br />
<br />
Post these visits, retire back to your hotel for an overnight stay. Feel free to explore the local markets of Pelling in the evening.</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> Transfer from Pelling and Gangtok Local Sightseeing
								</p>
								<p class="aj">Post breakfast, embark on a journey to the capital of Sikkim, Gangtok. The capital is around 116 km from Pelling, so you will have to leave early.<br />
<br />
Gangtok being one of the most popular places in Sikkim, is a major tourist destination that is dotted with several beautiful monasteries, and resides under the shadow of lofty Himalayan peaks. Most fascinating fact about Sikkim is that due to its proximity to Himalayan ranges, the destination offers a panoramic view of the mighty Kanchenjunga mountain, which is the highest in Sikkim. Apart from the alluring Himalayan beauty, Gangtok also has a rich cultural biodiversity flowing deep inside its city life.<br />
<br />
Drive to Gangtok is going to take around 2 hr and 30 mins. As soon as you reach your destination, you would be transferred to your hotel. After relaxing for sometime in the hotel, you will be heading for a sightseeing trip of Gangtok. Prominent tourist attractions that you would be visiting include Enchey monastery, Do Drul Chorten, Directorate of handicrafts and handlooms, Research institute of Tibetology and White Hall.<br />
<br />
Located 3 km from the main town of Gangtok, Enchey Monastery rules as the prime religious place in the city. Construction of this renowned monastery dates back to 200 years. Another major example of the Nyingma sect of Buddhism, Enchey monastery is believed to be blessed by Lama Druptab Karpo. In its early days, Enchey was basically a small hut. Later on, the present day structure started taking place in the form of a Chinese Pagoda. The prime attractions of this solitary monastery are the idols of Lord Buddha, Loki Sharia and Guru Padmasambhava. Besides the statue of them, the monastery also houses ancient images of Gods and Goddesses.<br />
<br />
Marked by a golden top dome, Do Drul Chorten stupa resides on a hillock. The construction of this remarkable structure has an interesting story to narrate. It is said that once the spot of this very stupa, used to be haunted by evil spirits, and caused human fatalities. In order to relieve the region of these evil spirits, a decorated lama of Tibet, Trulshig Rinpoche came to this place and built a religious stupa in the year 1946. This stupa later on got famous as Do Drul Chorten. Built along the principles of Nyingma order of Buddhism, the stupa holds great significance. It houses 108 prayer wheels that have Buddhist mantras inscribed over them.<br />
<br />
After offering your prayers at these sacred places, head towards the Research Institue of Tibetology, which is located very close to Do Drul Chorten stupa. The institute is famous for its huge collection of books on the culture of Sikkim and Tibetan work. Post this, visit Directorate of Handlooms and Handicrafts and White Hall. Then call it a day, and proceed back to your hotel for an overnight stay. In the evening, feel free to explore any good shopping market or a club nearby.</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> Excursion to Tsomgo Lake and Baba Mandir
								</p>
								<p class="aj">After having a sumptuous breakfast, leave for Tsomgo Lake and Baba Mandir on the alluring heights of Sikkim. First in the excursion is Tsomgo Lake which is around 39 km from Gangtok. Drive to the lake is likely to take around an hour.<br />
<br />
Situated at an altitude of around 12,400 ft, Tsomgo Lake or Changu Lake is one of the most beautiful spots in the whole of Sikkim. The glacial lake is home to a huge quantity of Brahmini ducks and migratory birds. Besides its natural beauty, Tsomgo lake is also a sacred lake that is highly visited by Buddhist and Hindu pilgrims. On the banks of the Tsomgo Lake lies a temple of Lord Shiva as well. The lake also has shops selling yak cheese and trinkets, situated on its banks. After having a wonderful time in this natural splendor, move towards a remarkable shrine, known as Baba Mandir.<br />
<br />
Baba Harbhajan Singh Memorial temple or simply Baba Mandir is a shrine that is located close to the Jelep La and Nathu La in the eastern part of Sikkim. The drive is around 16 km from Tsomgo Lake, which is likely to take close to 21 mins to reach. The popular shrine of Baba Harbhajan Singh has an interesting story to narrate. The story goes like this, there was a sepoy in the 23rd Punjab Regiment who died during the Indo-China war of 1962. One of his fellow soldiers saw him in his dream, asking to build a memorial in honor of him. This resulted in the construction of a memorial by the Indian army. This later on turned into a religious shrine. Owing to this, the shrine receives hundreds of pilgrims on a daily basis. As you will enter the temple of Baba Harbhajan Singh Memorial Temple, you will come across various belongings of the late soldier and an idol of him. This temple is highly devoted by army personnels posted in the region.<br />
<br />
By evening, you would return back to your hotel in Gangtok for an overnight stay. Feel free to make the last of your shoppings in the city at this time.</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> Departure from Gangtok
								</p>
								<p class="aj">After your morning breakfast, you would be transferred to New Jalpaiguri Railway Station (119 km) / Bagdogra Airport (126 km) / Tenzing Norgay Bus Stand (113 km) from your hotel in Gangtok. This brings the end of our amazing northeast tour.</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.journey99.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Delightful North East with Pelling 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="76469"/>
						</form>
						</div>
						
						";i:1;s:78:"Book Delightful North East with Pelling Tour - 6 Nights / 7 Days Tour Packages";i:2;s:148:"book delightful north east with pelling tour - 6 nights / 7 days tour packages, valley tour packages, gangtok, darjeeling, west sikkim tour packages";i:3;s:221:"Book Delightful North East with Pelling Tour - 6 Nights / 7 Days tour packages from Journey 99 ( a Unit of Dynamic Holidays ) - Get attractive 6 Nights / 7 Days Valley  tour packages for  Gangtok, Darjeeling, West Sikkim.";i:4;s:443:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Gangtok, Darjeeling, West Sikkim"        
		                 },
		      "description": "",
		      "name": "Delightful North East with Pelling Tour",
		      "telephone": "+91-9647433338"
		    }
		    </script>
			";i:5;N;}