a:6:{i:0;s:12169:"				<div class="h1"><h1>Gangtok 2 Darjeeling Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.grihapraveshtravels.in/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.grihapraveshtravels.in/tour-packages.htm" title="Tour Packages">Tour Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Gangtok 2 Darjeeling 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">
						4 Nights / 5 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Gangtok, Darjeeling</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.grihapraveshtravels.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Gangtok 2 Darjeeling 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="95522"/>
						</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_15/423905/162352.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/423905/162352.jpg"  width="150" height="150"    alt="Gangtok 2 Darjeeling Tour" title="Gangtok 2 Darjeeling Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					All transport service will be on point to point basis and not available for disposal.<br />
In small category Tsomgo lake & Baba Mandir and Lachung & Lachen is by done Tata Sumo/ Maxx<br />
In regular category Gangtok sightseeing is done by Wagon-R / Maruti Van / Alto 4 Seater.<br />
In regular category intercity transfer will be on stand to stand as the regular vehicle are not allowed inside the Gangtok town<br />
The mentioned rates are only applicable for Indian Nationals<br />
For Nathulla Pass special permit is required for which the guest document should reach us at least   before 10 days prior to arrival<br />
In case of Land slide or any reason Tsomgo Lake & Baba Mandir / North Sikkim (Lachen & Lachung) is closed we will provide alternate sightseeing and there will be no refunds. But if the permit is given then the vehicle will go till snowline and there will be no refunds in this case.<br />
After issue of permit for restricted areas i.e Tsomgo Lake & Baba Mandir / North Sikkim (Lachen & Lachung) if the guest is unable to cover all the places due to weather conditions or road conditions we will not provide any extra sightseeing in replace to that.<br />
The rates are valid only for the guest who are staying within the 1 KM radius of the main town<br />
The rates provided can be changed without any prior notice during blackout dates.<br />
 <br />
Passenger capacity<br />
Luxury Xylo / Innova / Scorpio (6 Seater)<br />
Small Wagon-R / Alto / Omni Van (4 Seater)<br />
 <br />
For Passes and Permits<br />
4 Copies PP size photos of each member travelling.<br />
2 photo copies of ID of each member travelling (Driving license / Voter ID / Passport only accepted) (Adhar Card and Pan card not accepted)<br />
Guest can send us the documents and photos via mail in case of emergency but in that case they will be charged Rs 60/- per person.<br />
 <br />
Cancellation Policy<br />
30 Days before Arrival Date Rs 2000/- for back office expense.<br />
Between 30 to 15 Days of arrival 25% of the total amount.<br />
Less than 15 days of arrival 50% of the total amount.<br />
7 Days before arrival 75% of the total amount.<br />
Less than 7 days of arrival 100% of the total amount<br />
Early checkout 100% of the total Amount.<br />
 <br />
Child Policy<br />
Up to 5 years complimentary without extra bed<br />
6 to 12 years charged as per child policy<br />
Above 12 years charged as Extra adults (with/without extra bed)<br />
<br />
Rooms on Twin/ Triple sharing basis<br />
Daily Breakfast & Dinner <br />
Exclusive Non-ac  vehicle. <br />
Luxury Taxes, Toll Taxes etc.Air Fare/Train fare.<br />
Personal Expenses such as Laundry, telephone calls, tips & gratuity. Mineral/soft/hard drinks, Rafting, Joy ride (Toy Train). <br />
Additional sightseeing or extra usage of vehicle, other than mentioned in the itinerary. <br />
Guide charges & Entrance Fees.<br />
Any cost arising due to natural calamities like, landslides, road blockage, political disturbances, etc (to be borne by the client, which is directly payable on the spot).<br />
Any increase in taxes or fuel price, leading to increase in cost on surface transportation & land arrangements, which may come into effect prior to departure.<br />
Service Tax, Insurance<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> IXB/ Njp to Gangtok
								</p>
								<p class="aj">Meet & Greet on arrival and transfer to 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 2:</b> Excursion to Tsomgo Lake and Baba Mandir
								</p>
								<p class="aj">After breakfast leave early at 7:30am for Tsomgo Lake and Baba Mandir. (Nathulla Pass is not included in the package and remains closed on Monday & Tuesday). Return back to Gangtok around 4.00 PM. Enjoy the evening at MG Marg.</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> Gangtok Half day S/S to Darjeeling
								</p>
								<p class="aj">After breakfast leave for half day local sightseeing covering Chorten Stupa, Rope Way, Flower Show, Bhanjhakri falls, Institute of Tibetalogy, Cottage Industry and later drive to Darjeeling. Overnight 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 4:</b> Darjeeling Full day sightseeing
								</p>
								<p class="aj">Early morning 4:00 am sharp Head for Tiger Hills (considered as most beautiful sunrise in the world) on the way back visit Ghoom Monastery and Batasia Loop. Get back into the hotel for fresh up. After breakfast Darjeeling Full day sightseeing, Zoological Park  & Himalayan Mountaineering Institute (Thursday close) View of Tea Garden, Refugee Centre, Tenzing Rock & Japanese Temple. Evening is free for leisure.</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> Darjeeling To IXB/NJP Drop
								</p>
								<p class="aj">After breakfast drop off to IXB/ NJP according to Train/ Flight Schedule.</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">Exclusions :</p> <ul><li>Air Fare/Train fare.</li><li>
Personal Expenses such as Laundry, telephone calls, tips & gratuity. Mineral/soft/hard drinks, Rafting, Joy ride (Toy Train). </li><li>
Additional sightseeing or extra usage of vehicle, other than mentioned in the itinerary. </li><li>
Guide charges & Entrance Fees.</li><li>
Any cost arising due to natural calamities like, landslides, road blockage, political disturbances, etc (to be borne by the client, which is directly payable on the spot).</li><li>
Any increase in taxes or fuel price, leading to increase in cost on surface transportation & land arrangements, which may come into effect prior to departure.</li><li>
Service Tax, Insurance</li></ul><br />
											
						<p class="large b mb5px dif">Terms &amp; Conditions :</p>~^#^~~^#^~<ul>
	<li>Terms &amp; Conditions and Do&rsquo;s &amp; Don&rsquo;t Hotel Details BOOK NOW</li>
	<li>Supplement Costs</li>
	<li>Supplement cost for Nathulla of Rs 5000/- Per Vehicle</li>
	<li>Supplement cost for Zero Point of Rs 3000/- Per Vehicle</li>
	<li>Supplement cost for Namchi of Rs 2500/- Per Vehicle</li>
</ul>						
    	<p class="h dif xlarge b mb5px">Rate Card</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">NO OF PAX (COST PER PERSON)</td>
				<td class="headHr p5px b">Deluxe (MAP) Premium  (MAP)</td>
			</tr>
			<tr>
				<td class="data p5px">02 PAX     (Non Ac Wagon R/ Alto)</td>
				<td class="data p5px">Rs 14’999/- Rs 17’599/-</td>
			</tr>
			<tr>
				<td class="data p5px">04 PAX (Non Ac Innova/ Xylo/ Scorpio)</td>
				<td class="data p5px">Rs 11’199/- Rs 13’999/-</td>
			</tr>
			<tr>
				<td class="data p5px">06 PAX (Non Ac Innova/ Xylo/ Scorpio)</td>
				<td class="data p5px">Rs 9’199/- Rs 11’999/-</td>
			</tr>
		</table></div><br>						</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.grihapraveshtravels.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Gangtok 2 Darjeeling 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="95522"/>
						</form>
						</div>
						
						";i:1;s:64:"Book Gangtok 2 Darjeeling Tour - 4 Nights / 5 Days Tour Packages";i:2;s:121:"book gangtok 2 darjeeling tour - 4 nights / 5 days tour packages, valley tour packages, gangtok, darjeeling tour packages";i:3;s:173:"Book Gangtok 2 Darjeeling Tour - 4 Nights / 5 Days tour packages from Grihapravesh Travels - Get attractive 4 Nights / 5 Days Valley  tour packages for  Gangtok, Darjeeling.";i:4;s:3468:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Gangtok, Darjeeling"        
		                 },
		      "description": "All transport service will be on point to point basis and not available for disposal.
In small category Tsomgo lake & Baba Mandir and Lachung & Lachen is by done Tata Sumo/ Maxx
In regular category Gangtok sightseeing is done by Wagon-R / Maruti Van / Alto 4 Seater.
In regular category intercity transfer will be on stand to stand as the regular vehicle are not allowed inside the Gangtok town
The mentioned rates are only applicable for Indian Nationals
For Nathulla Pass special permit is required for which the guest document should reach us at least   before 10 days prior to arrival
In case of Land slide or any reason Tsomgo Lake & Baba Mandir / North Sikkim (Lachen & Lachung) is closed we will provide alternate sightseeing and there will be no refunds. But if the permit is given then the vehicle will go till snowline and there will be no refunds in this case.
After issue of permit for restricted areas i.e Tsomgo Lake & Baba Mandir / North Sikkim (Lachen & Lachung) if the guest is unable to cover all the places due to weather conditions or road conditions we will not provide any extra sightseeing in replace to that.
The rates are valid only for the guest who are staying within the 1 KM radius of the main town
The rates provided can be changed without any prior notice during blackout dates.
 
Passenger capacity
Luxury Xylo / Innova / Scorpio (6 Seater)
Small Wagon-R / Alto / Omni Van (4 Seater)
 
For Passes and Permits
4 Copies PP size photos of each member travelling.
2 photo copies of ID of each member travelling (Driving license / Voter ID / Passport only accepted) (Adhar Card and Pan card not accepted)
Guest can send us the documents and photos via mail in case of emergency but in that case they will be charged Rs 60/- per person.
 
Cancellation Policy
30 Days before Arrival Date Rs 2000/- for back office expense.
Between 30 to 15 Days of arrival 25% of the total amount.
Less than 15 days of arrival 50% of the total amount.
7 Days before arrival 75% of the total amount.
Less than 7 days of arrival 100% of the total amount
Early checkout 100% of the total Amount.
 
Child Policy
Up to 5 years complimentary without extra bed
6 to 12 years charged as per child policy
Above 12 years charged as Extra adults (with/without extra bed)

Rooms on Twin/ Triple sharing basis
Daily Breakfast & Dinner 
Exclusive Non-ac  vehicle. 
Luxury Taxes, Toll Taxes etc.Air Fare/Train fare.
Personal Expenses such as Laundry, telephone calls, tips & gratuity. Mineral/soft/hard drinks, Rafting, Joy ride (Toy Train). 
Additional sightseeing or extra usage of vehicle, other than mentioned in the itinerary. 
Guide charges & Entrance Fees.
Any cost arising due to natural calamities like, landslides, road blockage, political disturbances, etc (to be borne by the client, which is directly payable on the spot).
Any increase in taxes or fuel price, leading to increase in cost on surface transportation & land arrangements, which may come into effect prior to departure.
Service Tax, Insurance",
		      "name": "Gangtok 2 Darjeeling Tour",
		      "telephone": "+91-9800718321"
		    }
		    </script>
			";i:5;N;}