a:6:{i:0;s:27312:"				<div class="h1"><h1>Essential New Zealand - Summer 2016 Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.grandindiatrip.com/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.grandindiatrip.com/tour-packages.htm" title="Tour Packages">Tour Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Essential New Zealand - Summer 2016 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">Duniya Dekho - Europ</td>
						</tr>
												<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">Auckland, Christchurch, Rotorua, Queenstown</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 224651 Per Person						</td>
						</tr>
												<tr>
						<td class="b p5px dif w125px vat">Special Offer </td>
						<td class="p5px pl0px dif vat">Panoramic city tour of Queenstown.<br />
<br />
Hotels Info<br />
<br />
City	Hotel Name<br />
Christchurch	<br />
Quality Hotel Elms Or Similar<br />
Queenstown	<br />
Mercure Grand St Moritz Or Similar<br />
Rotorua	<br />
Ibis Rotorua Hotel Or Similar<br />
Auckland	<br />
Auckland City Hotel Or Similar</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.grandindiatrip.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Essential New Zealand - Summer 2016 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="62382"/>
						</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_9/257644/116403.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/116403.jpg"  width="150" height="150"    alt="Essential New Zealand - Summer 2016 Tour" title="Essential New Zealand - Summer 2016 Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					New Zealand enthrals a traveler with its outlandish scenery, fabulous festivals, superb food & wine, and magical outdoor experiences. Equally impressive is the country's potent, mainstream Maori culture. This is a country that recognizes and celebrates its indigenous people - the world is a kinder, gentler, more respectful place down here! Christchurch is a beautiful city, a city where you can cycle alongside the river, indulge in fine sophisticated dining, and a city where, just 15 minutes from the centre you can scramble up mountain bike tracks or ride a wave at a surf beach. Queenstown sits on the shore of crystal clear Lake Wakatipu among dramatic ranges. Auckland's blend of harbour, islands, Polynesian culture and modern city environment has created a lifestyle ranked amongst the best in the world. Rotorua is the city, on the Volcanic Plateau, which has one of the world's most lively fields of geothermal activity<br />
<br />
Selected Hub:<br />
Change Hub <br />
Ex - Mumbai<br />
Starting From<br />
 2,24,651*Per Person<br />
<br />
Book Now<br />
<br />
HIGHLIGHTS-<br />
Visit Agrodome.<br />
Visit the Waitomo glow worm caves.<br />
Visit Antarctic Centre<br />
Hide.<br />
<br />
Important Note<br />
Minimum connecting time between international and domestic flights should be 4 and half hours prior to departure.<br />
Child without bed - Is an individual under 12 years of age, sharing the room with 2 Full Paying adults and without a bed / cot.<br />
In a room there can be maximum of 3 adultsAs a 3rd person in a Triple Room, some hotels use roll away beds or 2 queen size beds.<br />
The tour will be operated, with Cox & Kings Tour Leader, subject to a minimum of 20 full paying adult passengers travelling together.<br />
For Two Adults & Two Children (Both Under 12 Years) rooming together, the 1st Child will have to pay "Child with Bed" price and the 2nd Child will pay "Child without Bed" price.<br />
In the event that the group size is less than 20 adult passengers, you will be given an option of travelling on an FIT basis, by paying an additional FIT SupplementThe Tour will be conducted on a seat-in-coach basis for a group strength of 2- 20.<br />
The management reserves the right to claim any additional expenses incurred due to delay or changes in schedules of train, airplane, bus, ship or any other services.<br />
On days when certain attractions, sights, monuments, museums, etcare closed, the Tour Manager reserves the right to amend the Itinerary / cancel the visit<br />
For convenience of our passengers, we will sometimes amend the itineraryHowever the inclusions remain unchanged.<br />
The right to vary, amend, alter or withdraw any particular itinerary, departure or excursion rests entirley with the companyDue to demand of a particular airline the in / out points may changeServices, however, will remain unchanged.<br />
Indian lunches and dinners and local meals are pre set & a-la carte is not possible.<br />
Once an air ticket is issued, date change penalty cost will be applicableCheck with our Sales Officer for the applicable charges.<br />
Overseas Travel Insurance for the duration of the tour is included in the tour priceHowever, any passengers who wish to extend their stay will be required to pay additional charges.<br />
A part of your tour price will be taken in NZD from your L.R.Sas per the RBI / GOI regulations.<br />
The company shall not accept any liability or responsibility for any damages, loss of baggage, loss, injury, accident, death, breakdown or irregularity, which may occur in carrying out tour arrangements due to weather conditions, strikes, war, threat of war, quarantine or any other cause whatsoever and all such loss or expenses must be borne by the passengers.<br />
There are no refunds for any services i.emeals, sightseeing, etc not utilized on your tour<br />
The tour manager and driver will do their best to get you as close to the monuments as possible, because in some cities coaches are restricted<br />
Passengers booking the Tour will have to pay any additional supplement amount, applicable from time to time, with immediate effect, on account of fuel hikes, any Government Taxes, Levy, by the respective Government or Statutory bodies, as and when applicable.<br />
Any damage caused to hotel rooms/coach during your stay, shall be borne by the concerned passengers.Panoramic city tour of Queenstown.<br />
<br />
Hotels Info<br />
<br />
City	Hotel Name<br />
Christchurch	<br />
Quality Hotel Elms Or Similar<br />
Queenstown	<br />
Mercure Grand St Moritz Or Similar<br />
Rotorua	<br />
Ibis Rotorua Hotel Or Similar<br />
Auckland	<br />
Auckland City Hotel Or SimilarOptional & Add-On tours unless mentioned otherwise.<br />
Cost of USD 2,50,000 granted by the Reserve Bank of India under the Liberalised Remittance Scheme.<br />
Any increase in the fuel charges / visa / airfare / taxes / routing charged by the airlines for tickets (presently calculated on 01 Sep 2015).<br />
Airline and Hotel surcharges (if applicable) during high / festive season / trade fairs to be paid extra per person.<br />
Cost of extension of validity or deviation of your air ticket.<br />
Medical test & Premium cost of your Trawell tag / Assist with Insurance valid for passengers above 70 years of age.<br />
Passport Charges.<br />
Any increase in the rate of NZD leading to an increase in Tour Cost coming into effect prior to departure. However, the rate of exchange on the given day of payment will apply.<br />
Porterage at hotels, apartment, airports and seaports, tips, laundry, wines, mineral water, telephone charges, all items of personal nature and also food and drinks not forming part of the touring group's menu.<br />
Anything not specifically mentioned in 'What Your Tour Price Includes' box.<br />
An additional amount of INR 1,500 is to be compulsorily paid by way of "Secure your Booking Amount".<br />
Baggage handling fee charged by the operating airline for the excess check-in baggage.<br />
Cost of additional sector tickets for further internal travel within New Zealand It is compulsory to purchase these tickets through Cox & Kings only at extra cost plus service charges. The tickets must be issued prior to travel from India.<br />
Govt. Service Tax 4.50% on gross bill effective 1st June 2016.<br />
Cost of any private transfers taken to move from one place to another instead of coach as per tour itinerary<br />
Any extra expenses incurred for route change, airline change/ date change/accommodation due to any unforeseen circumstances, forced majuire instances, natural calamities, political disturbances, strikes etc16-0630-09<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 Christchurch
								</p>
								<p class="aj">Welcome to your 'Essential New Zealand' tour!<br />
<br />
On arrival in Christchurch, you will be met and transferred by our local representative to the hotel. (Check-in after 1400 hrs)<br />
Experience Christchurch's scenic beauty. Visit International Antarctic Centre and learn about penguins. Enjoy the city tour of Mona Vale gardens, Cathedral, Museum and Art Centre, Avon River, Bridge of Remembrance, Kashmere Hills, newly opened pop up container mall.<br />
The rest of the day is at leisure for independent activities.<br />
Overnight in Christchurch.<br />
Dinner at an Indian restaurant.</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> Onto Queenstown
								</p>
								<p class="aj">Today embark on a scenic drive. Proceed towards Queenstown, through Canterbury Plains. Photo stop at Church Of Good Shepherd. Proceed to Lake Tekapo, Lake Pukaki, Mt. Cook lookout point and glacier region. You may opt for Helicopter Ride at Mount Cook. En route photo stops.<br />
Visit Puzzling World at Wanaka. Experience thrills while walking through pathways at the maze and find the way. Arrive Queenstown. Proceed for a city tour, viewing Lake Hayes, in Wakatipu basin, renowned for its scenic beauty, AJ Hackett Bungy Bridge, historic Arrowtown, Edith Cawell Bridge. Enjoy a Gondola Ride to Bobs peak for stunning views. Check-in at hotel (check in after 1400 hrs ).<br />
Overnight in Queenstown.</p>					
									<p><b>Meals : </b> Breakfast at the hotel restaurant, Lunch and Dinner at an Indian restaurant.</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> In Queenstown
								</p>
								<p class="aj">Today explore the scenic surroundings beyond Queenstown, as you travel to Fiordland. Enjoy Milford Sound Cruise. Drive through scenic landscapes and pass by Te Anau town. Situated within Fiordland National Park, part of Te Wahipounamu World Heritage site, lies New Zealand's most stunning natural attraction - Milford Sound. Milford Sound is the best known of all the Fiords in New Zealand. At the pinnacle of Milford Sound is the magnetising Mitre Peak - a prominent peak on the south shore of Milford Sound, standing a proud 1,692 metres above sea level, it is certainly an impressive sight to be hold. The Peak actually consists of five closely grouped individual peaks. Bounded by towering steep cliffs and dense forests and peaks, behold the beautiful pristine scenery. Watch out for seals, dolphins and penguins. Return to hotel in Queenstown.<br />
Overnight in Queenstown.</p>					
									<p><b>Meals : </b> Breakfast at the hotel restaurant, Lunch and Dinner at an Indian restaurant.</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> In Queenstown
								</p>
								<p class="aj">The day is at leisure or you can opt for any of the optional activities like Bungy Jumping, Shotover Jet Ride, Ziplining, Paragliding, Skydiving.<br />
Overnight in Queenstown.</p>					
									<p><b>Meals : </b> Breakfast at the hotel restaurant, Lunch and Dinner at an Indian restaurant</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> Queenstown - Auckland - Rotorua
								</p>
								<p class="aj">After breakfast, check-out and transfer to the airport for your flight to Auckland.<br />
<br />
On arrival in Auckland, drive to Rotorua. Rotorua, located on a volcanic plateau, is the heartland of Maori culture and the centre of New Zealand's spectacular geothermal wonders. After arrival, check into the hotel (check in after 1400 hrs).<br />
Overnight in Rotorua</p>					
									<p><b>Meals : </b> Breakfast at the hotel restaurant, Lunch & Dinner at an Indian restaurant.</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> Rotorua
								</p>
								<p class="aj">On arrival, proceed for a panoramic city tour of Rotorua. Visit the Agrodome and watch the Sheep Shearing Show. Get an insight into New Zealand agriculture. Visit Te Puia, Rotorua's best known reserve of thermal springs; formerly known as Whakarewarewa Hot Springs where boiling mud pools and roaring geysers greet you. Opt for Polynesian Spa. Then visit the Maori Arts & Crafts Institute.<br />
After dinner, return to your hotel.<br />
Overnight in Rotorua.</p>					
									<p><b>Meals : </b> Breakfast at the hotel restaurant, Lunch & Dinner at an Indian restaurant.</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> Rotorua - Auckland
								</p>
								<p class="aj">Proceed to explore Waikato region. Visit world renowned Waitomo Caves. Enjoy the spectacular caves with its majestic and ornate decorations, the deep limestone shaft known as the Tomo and the equally magnificent Cathedral. Take a boat ride through the Glowworm Grotto. Proceed to Hamilton. Visit Hamilton Gardens. Take a journey of discovery along paths delivering mysterious surprises: step from a peaceful Sung Dynasty Chinese Scholar's garden into an Italian Renaissance Garden, before being enthralled by the grandeur of the Indian Char Bagh ('four quartered') Garden, overlooking the Waikato River. Proceed to Auckland and continue for a panoramic city tour including Queen Street, pass through Auckland University grounds, historic buildings, Harbour Bridge, Viaduct Harbour, Queen Street, Michael Savage Memorial Park and Tamaki Drive. Visit SkyTower. (Entry only) Later, check-in at the hotel.<br />
Overnight in Auckland.</p>					
									<p><b>Meals : </b> Breakfast at the hotel restaurant, Lunch and Dinner at an Indian restaurant.</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> Depart Auckland
								</p>
								<p class="aj">Good times need never end!!<br />
As you get ready for the airport and your flight back home, relive the high points of your 'Essential New Zealand' tour. We are confident you will join us again sometime soon.</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>Flights</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>Optional & Add-On tours unless mentioned otherwise.</li><li>
Cost of USD 2,50,000 granted by the Reserve Bank of India under the Liberalised Remittance Scheme.</li><li>
Any increase in the fuel charges / visa / airfare / taxes / routing charged by the airlines for tickets (presently calculated on 01 Sep 2015).</li><li>
Airline and Hotel surcharges (if applicable) during high / festive season / trade fairs to be paid extra per person.</li><li>
Cost of extension of validity or deviation of your air ticket.</li><li>
Medical test & Premium cost of your Trawell tag / Assist with Insurance valid for passengers above 70 years of age.</li><li>
Passport Charges.</li><li>
Any increase in the rate of NZD leading to an increase in Tour Cost coming into effect prior to departure. However, the rate of exchange on the given day of payment will apply.</li><li>
Porterage at hotels, apartment, airports and seaports, tips, laundry, wines, mineral water, telephone charges, all items of personal nature and also food and drinks not forming part of the touring group's menu.</li><li>
Anything not specifically mentioned in 'What Your Tour Price Includes' box.</li><li>
An additional amount of INR 1,500 is to be compulsorily paid by way of "Secure your Booking Amount".</li><li>
Baggage handling fee charged by the operating airline for the excess check-in baggage.</li><li>
Cost of additional sector tickets for further internal travel within New Zealand It is compulsory to purchase these tickets through Cox & Kings only at extra cost plus service charges. The tickets must be issued prior to travel from India.</li><li>
Govt. Service Tax 4.50% on gross bill effective 1st June 2016.</li><li>
Cost of any private transfers taken to move from one place to another instead of coach as per tour itinerary</li><li>
Any extra expenses incurred for route change, airline change/ date change/accommodation due to any unforeseen circumstances, forced majuire instances, natural calamities, political disturbances, strikes etc</li></ul><br />
												<p class="large b mb5px dif">Specific Departure Dates :</p>Mumbai<br />
Delhi<br />
Kolkata<br />
Chennai<br />
July 2016	-	02<br />
August 2016	-	13<br />
September 2016	-	17,30<br />
												<p class="large b mb5px dif">Departure Cities with rates :</p>Helicopter Ride Mt. Cook (20 Min Snow Landing) [entrance Only]
Helicopter Ride Mt. Cook (20 Min Snow Landing) [entrance Only]
View vast snowfields, glaciers and New Zealand's highest peak Aoraki/Mount Cook on a Helicopter Ride as you fly via the Ben Ohau Mountain Range, viewing spectacular hanging glaciers and rivers of moving ice. Then descend beside the beautiful turquoise hues of the glacially fed Lake Pukaki to complete a flight you will never forget.<br /><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. ~^#^~						
    	<p class="h dif xlarge b mb5px">Package Cost Ex - Mumbai - Valid from 8th Feb, 2016 to 30th Sep, 2016</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headVr p5px">Type</td>
				<td class="data p5px">Price</td>
				<td class="data p5px">Discount Offer</td>
				<td class="data p5px">Total in INR After Discount</td>
			</tr>
			<tr>
				<td class="headVr p5px">Twin</td>
				<td class="data p5px">INR 2,39,011(NZD 1890 + INR 1,42,999)</td>
				<td class="data p5px">INR 16,360</td>
				<td class="data p5px">INR 2,22,651</td>
			</tr>
			<tr>
				<td class="headVr p5px">Triple</td>
				<td class="data p5px">INR 2,39,011(NZD 1890 + INR 1,42,999)</td>
				<td class="data p5px">INR 16,360</td>
				<td class="data p5px">INR 2,22,651</td>
			</tr>
			<tr>
				<td class="headVr p5px">Single</td>
				<td class="data p5px">INR 2,67,459(NZD 2450 + INR 1,42,999)</td>
				<td class="data p5px">INR 18,242</td>
				<td class="data p5px">INR 2,49,217</td>
			</tr>
			<tr>
				<td class="headVr p5px">Child with bed</td>
				<td class="data p5px">INR 2,14,103(NZD 1380 + INR 1,43,999)</td>
				<td class="data p5px">INR 14,717</td>
				<td class="data p5px">INR 1,99,386</td>
			</tr>
			<tr>
				<td class="headVr p5px">Child without bed</td>
				<td class="data p5px">INR 2,01,403(NZD 1130 + INR 1,43,999)</td>
				<td class="data p5px">INR 13,877</td>
				<td class="data p5px">INR 1,87,526</td>
			</tr>
			<tr>
				<td class="headVr p5px">Infant</td>
				<td class="data p5px">INR 95,000(NZD + INR 95,000)</td>
				<td class="data p5px">INR 0</td>
				<td class="data p5px">INR 95,000</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Package Cost Ex - Delhi - Valid from 8th Feb, 2016 to 30th Sep, 2016</p>
    	<div class="otherDetails aj">Package Air Surcharge Price<br>
Adult Child Infant<br>
<br>
Unsecured Reservation Fee INR 3000 per person<br>
Booking Amount and Note INR 40000 per person ( Interest free and non - refundable) adjusted against the tour cost<br>
<br>
Package Optional Excursion<br>
Adult Child Infant<br>
Helicopter Ride MtCook (20 Min Snow Landing) [Entrance Only]NZD 255NZD 200NA</div><br>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headVr p5px">Type</td>
				<td class="data p5px">Price</td>
				<td class="data p5px">Discount Offer</td>
			</tr>
			<tr>
				<td class="headVr p5px">Twin</td>
				<td class="data p5px">INR 2,44,011(NZD 1890 + INR 1,47,999)</td>
				<td class="data p5px">INR 16,710</td>
			</tr>
			<tr>
				<td class="headVr p5px">Triple</td>
				<td class="data p5px">INR 2,44,011(NZD 1890 + INR 1,47,999)</td>
				<td class="data p5px">INR 16,710</td>
			</tr>
			<tr>
				<td class="headVr p5px">Single</td>
				<td class="data p5px">INR 2,72,459(NZD 2450 + INR 1,47,999)</td>
				<td class="data p5px">INR 18,592</td>
			</tr>
			<tr>
				<td class="headVr p5px">Child with bed</td>
				<td class="data p5px">INR 2,18,103(NZD 1380 + INR 1,47,999)</td>
				<td class="data p5px">INR 14,999</td>
			</tr>
			<tr>
				<td class="headVr p5px">Child without bed</td>
				<td class="data p5px">INR 2,05,403(NZD 1130 + INR 1,47,999)</td>
				<td class="data p5px">INR 14,157</td>
			</tr>
			<tr>
				<td class="headVr p5px">Infant</td>
				<td class="data p5px">INR 95,000(NZD + INR 95,000)</td>
				<td class="data p5px">INR 0</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Package Pre - Post Night Price</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headVr p5px">Type</td>
				<td class="data p5px">Pre Night - Christchurch - Quality Hotel Elms Or Similar</td>
				<td class="data p5px">Post Night - Auckland - Auckland City Hotel Or Similar</td>
			</tr>
			<tr>
				<td class="headVr p5px">Twin</td>
				<td class="data p5px">NZD 90</td>
				<td class="data p5px">NZD 70</td>
			</tr>
			<tr>
				<td class="headVr p5px">Triple</td>
				<td class="data p5px">NZD 90</td>
				<td class="data p5px">NZD 70</td>
			</tr>
			<tr>
				<td class="headVr p5px">Single</td>
				<td class="data p5px">NZD 170</td>
				<td class="data p5px">NZD 140</td>
			</tr>
			<tr>
				<td class="headVr p5px">Child with bed</td>
				<td class="data p5px">NZD 75</td>
				<td class="data p5px">NZD 60</td>
			</tr>
			<tr>
				<td class="headVr p5px">Child without bed</td>
				<td class="data p5px">NZD 60</td>
				<td class="data p5px">NZD 50</td>
			</tr>
		</table></div><br>						</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.grandindiatrip.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Essential New Zealand - Summer 2016 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="62382"/>
						</form>
						</div>
						
						";i:1;s:79:"Book Essential New Zealand - Summer 2016 Tour - 7 Nights / 8 Days Tour Packages";i:2;s:162:"book essential new zealand - summer 2016 tour - 7 nights / 8 days tour packages, heritage tour packages, auckland, christchurch, rotorua, queenstown tour packages";i:3;s:221:"Book Essential New Zealand - Summer 2016 Tour - 7 Nights / 8 Days tour packages from Grand India Tours & Travels - Get attractive 7 Nights / 8 Days Heritage  tour packages for  Auckland, Christchurch, Rotorua, Queenstown.";i:4;s:6813:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Auckland, Christchurch, Rotorua, Queenstown"        
		                 },
		      "description": "New Zealand enthrals a traveler with its outlandish scenery, fabulous festivals, superb food & wine, and magical outdoor experiences. Equally impressive is the country's potent, mainstream Maori culture. This is a country that recognizes and celebrates its indigenous people - the world is a kinder, gentler, more respectful place down here! Christchurch is a beautiful city, a city where you can cycle alongside the river, indulge in fine sophisticated dining, and a city where, just 15 minutes from the centre you can scramble up mountain bike tracks or ride a wave at a surf beach. Queenstown sits on the shore of crystal clear Lake Wakatipu among dramatic ranges. Auckland's blend of harbour, islands, Polynesian culture and modern city environment has created a lifestyle ranked amongst the best in the world. Rotorua is the city, on the Volcanic Plateau, which has one of the world's most lively fields of geothermal activity

Selected Hub:
Change Hub 
Ex - Mumbai
Starting From
 2,24,651*Per Person

Book Now

HIGHLIGHTS-
Visit Agrodome.
Visit the Waitomo glow worm caves.
Visit Antarctic Centre
Hide.

Important Note
Minimum connecting time between international and domestic flights should be 4 and half hours prior to departure.
Child without bed - Is an individual under 12 years of age, sharing the room with 2 Full Paying adults and without a bed / cot.
In a room there can be maximum of 3 adultsAs a 3rd person in a Triple Room, some hotels use roll away beds or 2 queen size beds.
The tour will be operated, with Cox & Kings Tour Leader, subject to a minimum of 20 full paying adult passengers travelling together.
For Two Adults & Two Children (Both Under 12 Years) rooming together, the 1st Child will have to pay "Child with Bed" price and the 2nd Child will pay "Child without Bed" price.
In the event that the group size is less than 20 adult passengers, you will be given an option of travelling on an FIT basis, by paying an additional FIT SupplementThe Tour will be conducted on a seat-in-coach basis for a group strength of 2- 20.
The management reserves the right to claim any additional expenses incurred due to delay or changes in schedules of train, airplane, bus, ship or any other services.
On days when certain attractions, sights, monuments, museums, etcare closed, the Tour Manager reserves the right to amend the Itinerary / cancel the visit
For convenience of our passengers, we will sometimes amend the itineraryHowever the inclusions remain unchanged.
The right to vary, amend, alter or withdraw any particular itinerary, departure or excursion rests entirley with the companyDue to demand of a particular airline the in / out points may changeServices, however, will remain unchanged.
Indian lunches and dinners and local meals are pre set & a-la carte is not possible.
Once an air ticket is issued, date change penalty cost will be applicableCheck with our Sales Officer for the applicable charges.
Overseas Travel Insurance for the duration of the tour is included in the tour priceHowever, any passengers who wish to extend their stay will be required to pay additional charges.
A part of your tour price will be taken in NZD from your L.R.Sas per the RBI / GOI regulations.
The company shall not accept any liability or responsibility for any damages, loss of baggage, loss, injury, accident, death, breakdown or irregularity, which may occur in carrying out tour arrangements due to weather conditions, strikes, war, threat of war, quarantine or any other cause whatsoever and all such loss or expenses must be borne by the passengers.
There are no refunds for any services i.emeals, sightseeing, etc not utilized on your tour
The tour manager and driver will do their best to get you as close to the monuments as possible, because in some cities coaches are restricted
Passengers booking the Tour will have to pay any additional supplement amount, applicable from time to time, with immediate effect, on account of fuel hikes, any Government Taxes, Levy, by the respective Government or Statutory bodies, as and when applicable.
Any damage caused to hotel rooms/coach during your stay, shall be borne by the concerned passengers.Panoramic city tour of Queenstown.

Hotels Info

City	Hotel Name
Christchurch	
Quality Hotel Elms Or Similar
Queenstown	
Mercure Grand St Moritz Or Similar
Rotorua	
Ibis Rotorua Hotel Or Similar
Auckland	
Auckland City Hotel Or SimilarOptional & Add-On tours unless mentioned otherwise.
Cost of USD 2,50,000 granted by the Reserve Bank of India under the Liberalised Remittance Scheme.
Any increase in the fuel charges / visa / airfare / taxes / routing charged by the airlines for tickets (presently calculated on 01 Sep 2015).
Airline and Hotel surcharges (if applicable) during high / festive season / trade fairs to be paid extra per person.
Cost of extension of validity or deviation of your air ticket.
Medical test & Premium cost of your Trawell tag / Assist with Insurance valid for passengers above 70 years of age.
Passport Charges.
Any increase in the rate of NZD leading to an increase in Tour Cost coming into effect prior to departure. However, the rate of exchange on the given day of payment will apply.
Porterage at hotels, apartment, airports and seaports, tips, laundry, wines, mineral water, telephone charges, all items of personal nature and also food and drinks not forming part of the touring group's menu.
Anything not specifically mentioned in 'What Your Tour Price Includes' box.
An additional amount of INR 1,500 is to be compulsorily paid by way of "Secure your Booking Amount".
Baggage handling fee charged by the operating airline for the excess check-in baggage.
Cost of additional sector tickets for further internal travel within New Zealand It is compulsory to purchase these tickets through Cox & Kings only at extra cost plus service charges. The tickets must be issued prior to travel from India.
Govt. Service Tax 4.50% on gross bill effective 1st June 2016.
Cost of any private transfers taken to move from one place to another instead of coach as per tour itinerary
Any extra expenses incurred for route change, airline change/ date change/accommodation due to any unforeseen circumstances, forced majuire instances, natural calamities, political disturbances, strikes etc16-0630-09",
		      "name": "Essential New Zealand - Summer 2016 Tour",
		      "telephone": "+91-9415285186"
		    }
		    </script>
			";i:5;N;}