a:6:{i:0;s:24672:"				<div class="h1"><h1>Best of China Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="https://www.grandindiatrip.com/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="https://www.grandindiatrip.com/tour-packages.htm" title="Tour Packages">Tour Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Best of China 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">Amezing china</td>
						</tr>
												<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">Beijing, Shanghai</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 85400 Per Person						</td>
						</tr>
												<tr>
						<td class="b p5px dif w125px vat">Special Offer </td>
						<td class="p5px pl0px dif vat">ocuments required for VISA: <br />
Original passport with minimum 6 months validity from the date of travel.<br />
2 white back ground recent passport size photo.<br />
Total Seats:- 30 <br />
Note: we will not encourage on arrival visa.<br />
Kindly ensure that your passport is valid for minimum 6 months beyond the stay, ECNR/POE formalities completed, etc.<br />
Two passport size photographs and copy of passport & pan card in full duly signed by the customer need to be submitted to IRCTC within three days of the booking.<br />
Above rates are subject to availability.<br />
Cancellation charges as per company policy.<br />
Room categories in all packages are the base category rooms unless stated otherwise.<br />
Final confirmation in the proposed hotels is subject to the availability at the time of booking, else similar category hotel will be provided.<br />
Please reach the airport 3 hours before the departure of the flight. IRCTC will not responsible for missing of flights by the guest.<br />
In flight food and beverages are on chargeable basis.<br />
Kindly reconfirm the departure terminal and the flight schedule from the airline before leaving for the airport.<br />
Web check in is not possible in our group packages.<br />
Transfers and Sightseeing tours are on SIC (seat in coach) / shared basis by A/C vehicle.<br />
Arrival / departure transfers & sightseeing tours shall be provided as per schedule.<br />
However this may require you to wait at the airport for short duration until all the guests arriving at that time exit the airport.<br />
The request for an adjacent or an adjoining room will be on subject to availability.<br />
It is mandatory to carry the age proof of children (02 to 11 yrs) and infant (below 02yrs) as well along with other travel documents. Child above than 11 yrs shall be considered for an adult cost.<br />
In airline no seat is provided to Infant.<br />
Room allocation (Twin bed / Double bed) is at the discretion of the hotel. The check in and check out time of the hotel is 12 to 12 noon. Numbers of meals are always corresponding to the number of nights booked. Breakfast is not provided on the day of arrival.<br />
In hotels for an extra Adult / Child either Rollaway bed or mattress shall be provided.<br />
For early check in and late check out the payment is to be settled directly by the guest.<br />
Hotel has the right to claim the damages incurred by any of the guest.<br />
The guests are requested to take care of their personal belongings carefully and avoid leaving them unattended.<br />
The airfares and taxes are calculated as on a mentioned date and any increase in the Taxes or airfares will be borne by the customer.<br />
For any change in Flight Timings/diversions, Flight cancellation from the airline IRCTC will not be responsible and if it further affects the Sightseeing/Itinerary client need to accommodate accordingly.<br />
Cost of additional services availed by the guest which are not part of our package inclusions are to be settled directly at the hotel.<br />
Buffet/Fixed meal will be provided at fixed venue decided by the hotel.<br />
You are kindly requested to check the perfect buffet timings at the time of check in at the hotel. Once the buffet time is over the hotel might ask you to pay for your meals.<br />
IRCTC request you that before finalizing the tour with us kindly go through the website of the hotels and read the reviews.<br />
Package cost is calculated on lowest class Air Fare. Any increase in air fare or air port taxes has to be borne by the client.<br />
Any Itinerary posted on the website is only a proposed holiday outline.<br />
In case there is any change in price the same will be communicated to yourself and only after your confirmation, we will proceed further.<br />
There will be no refund for un-utilized services.<br />
The package Price is subject to change without prior notice.<br />
Above tour prices are subject to change in the event of increase in hotel room rates levy by the hotel especially during peak season / holiday surcharge and major events/ fairs and convention.<br />
Passenger should get full briefing about the tour from IRCTC before/after the booking to avoid any confusion.<br />
IRCTC is not liable for personnel expenses, boating, porterage, theft, accidents etc.<br />
Any other terms and conditions applied as may be decided by IRCTC at any point of time.</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="https://www.grandindiatrip.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Best of China 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="58663"/>
						</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/110916.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/110916.jpg"  width="150" height="150"    alt="Best of China Tour" title="Best of China Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					<b>Description:</b><br />
Everything about China is larger than life and so is the experience that it bestows on travellers, who come to explore this gigantic Asian country. Today, people around the world know China for its economic growth but the country has more to its fame and name. It is a marvellous land with diverse geographical realms and culture that dates back to 17th century BC. A trip to China offers a wonderful chance to experience unique combination of crowded metropolitan cities and rural landscapes that flaunt unimaginable natural beauty. The country is home to the world's largest population and also a plethora of heritage sites. The mainland China has some highly cosmopolitan cities, among which Beijing- the capital, holds a supreme status. Xian, a former capital and the oldest of all the cities in China, is another place that attracts visitors on a China trip. Ten important dynasties of the region, including Tang and Han, originated from this history-rich city. Other major cities that tourists must include in their itinerary are Hangzhou, Kunming, Nanjing, Suzhou (popularly known as 'Venice of the East'), Guilin (known for scenic landscapes and picturesque mountains), Shanghai (major commercial centre and the country's largest city) and Guangzhou. There are modern entertainment facilities in China's metropolitan cities; however, the real tourist attractions are the heritage sites. One will be amazed to know that China is the third country in the list of countries with most heritage sites. The Great Wall of China tops the list of historic sites in the region and is the longest man-made structure till date. The Terracotta Army is another major tourist attraction in Xian and depicts a necropolis of terracotta sculptures built during the reign of Qin Shi Huang, the first Emperor of China. Other sites that make China a place worth-visiting are the Forbidden City, Mogao Caves, Peking Man, Ancient City of Ping Yao, Chengjiang Fossil Site and the capital cities and tombs of the Ancient Koguryo Kingdom. Holiday in China would be incomplete if one doesn't include the blessed-by-nature scenic spots. The Jiuzhaigou Valley is quite famous for its colourful lakes, snow-clad peaks and numerous waterfalls. Other natural sites for tourists to see are Mount Taishan, Mount Huangshan, Mount Emei scenic area featuring the famous Leshan Giant Buddha sculpture, and Sichuan Giant Panda Sanctuaries. One can avail an exciting China tour package from Yatra.com to travel around the country in a convenient and of course, a cost-effective manner.<br />
Route :  Chennai - Beijing - Shanghai - Chennai<br />
IRCTC Flight Packages<br />
Traveling Mode - By Flight<br />
Station/Departure Time	- Chennai airport at 01:40 hrs.<br />
Class - Comfort<br />
Tour Date - 18/June/2016<br />
Hotel Name<br />
Beijing - J Hotel / Similar<br />
Shanghai - Ramada Hotel / Similarocuments required for VISA: <br />
Original passport with minimum 6 months validity from the date of travel.<br />
2 white back ground recent passport size photo.<br />
Total Seats:- 30 <br />
Note: we will not encourage on arrival visa.<br />
Kindly ensure that your passport is valid for minimum 6 months beyond the stay, ECNR/POE formalities completed, etc.<br />
Two passport size photographs and copy of passport & pan card in full duly signed by the customer need to be submitted to IRCTC within three days of the booking.<br />
Above rates are subject to availability.<br />
Cancellation charges as per company policy.<br />
Room categories in all packages are the base category rooms unless stated otherwise.<br />
Final confirmation in the proposed hotels is subject to the availability at the time of booking, else similar category hotel will be provided.<br />
Please reach the airport 3 hours before the departure of the flight. IRCTC will not responsible for missing of flights by the guest.<br />
In flight food and beverages are on chargeable basis.<br />
Kindly reconfirm the departure terminal and the flight schedule from the airline before leaving for the airport.<br />
Web check in is not possible in our group packages.<br />
Transfers and Sightseeing tours are on SIC (seat in coach) / shared basis by A/C vehicle.<br />
Arrival / departure transfers & sightseeing tours shall be provided as per schedule.<br />
However this may require you to wait at the airport for short duration until all the guests arriving at that time exit the airport.<br />
The request for an adjacent or an adjoining room will be on subject to availability.<br />
It is mandatory to carry the age proof of children (02 to 11 yrs) and infant (below 02yrs) as well along with other travel documents. Child above than 11 yrs shall be considered for an adult cost.<br />
In airline no seat is provided to Infant.<br />
Room allocation (Twin bed / Double bed) is at the discretion of the hotel. The check in and check out time of the hotel is 12 to 12 noon. Numbers of meals are always corresponding to the number of nights booked. Breakfast is not provided on the day of arrival.<br />
In hotels for an extra Adult / Child either Rollaway bed or mattress shall be provided.<br />
For early check in and late check out the payment is to be settled directly by the guest.<br />
Hotel has the right to claim the damages incurred by any of the guest.<br />
The guests are requested to take care of their personal belongings carefully and avoid leaving them unattended.<br />
The airfares and taxes are calculated as on a mentioned date and any increase in the Taxes or airfares will be borne by the customer.<br />
For any change in Flight Timings/diversions, Flight cancellation from the airline IRCTC will not be responsible and if it further affects the Sightseeing/Itinerary client need to accommodate accordingly.<br />
Cost of additional services availed by the guest which are not part of our package inclusions are to be settled directly at the hotel.<br />
Buffet/Fixed meal will be provided at fixed venue decided by the hotel.<br />
You are kindly requested to check the perfect buffet timings at the time of check in at the hotel. Once the buffet time is over the hotel might ask you to pay for your meals.<br />
IRCTC request you that before finalizing the tour with us kindly go through the website of the hotels and read the reviews.<br />
Package cost is calculated on lowest class Air Fare. Any increase in air fare or air port taxes has to be borne by the client.<br />
Any Itinerary posted on the website is only a proposed holiday outline.<br />
In case there is any change in price the same will be communicated to yourself and only after your confirmation, we will proceed further.<br />
There will be no refund for un-utilized services.<br />
The package Price is subject to change without prior notice.<br />
Above tour prices are subject to change in the event of increase in hotel room rates levy by the hotel especially during peak season / holiday surcharge and major events/ fairs and convention.<br />
Passenger should get full briefing about the tour from IRCTC before/after the booking to avoid any confusion.<br />
IRCTC is not liable for personnel expenses, boating, porterage, theft, accidents etc.<br />
Any other terms and conditions applied as may be decided by IRCTC at any point of time.Any increase in Airfare.<br />
Any increase in Airport Taxes, Fuel Surcharge.<br />
Meals are preset & Choice of menu is not available.<br />
All Kinds of tips to drivers, guides, representative etc.<br />
Any expenses of personal nature such a laundry expenses, wine, mineral water, food and drinks other than mentioned in the regular menu.<br />
Any services not specified in the inclusion Activities of any kind are excluded in the package.<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> India /Beijing
								</p>
								<p class="aj">Fly to China, arrive at Beijing Capital Int’l Airport, airport pick up with our English-speaking airport representative, only transfer to hotel and take a rest. Proceed to see the Bird’s Nest (Olympic National Stadium outside) and the Water Cube (Outside).<br />
Indian Dinner.<br />
Indian Lunch+ Indian Dinner at 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> Beijing
								</p>
								<p class="aj">Breakfast at hotel, visit to the world famous Tian'anmen Square the biggest square in the world that lies in the center of the city. Then the Forbidden City from which the Emperors of the Ming and Qing dynasties governed for over 500 years. Pearl shop, and visit the Summer Palace, the largest and best preserved of all the imperial palace gardens, and boasts such delights as the “Marble Boat” and the ornately painted "Long Corridor", Gongfu Show in the evening.<br />
Breakfast + Indian Lunch+ Indian Dinner at 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> Beijing
								</p>
								<p class="aj">Breakfast at hotel, Begin today’s full tour with a visit to a Longdi Jade shop where we will learn about Chinese jade culture. In the afternoon, visit the fabled Great Wall-Juyong Pass, a UNESCO World Heritage Site and a massive defensive structure built to keep off intrusion and Yaxiu market for shopping. Gala Dinner with hard drink at Indian Restaurant with Belly Dance.<br />
Breakfast + Indian Lunch+ Indian Dinner at 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> Beijing - Shanghai
								</p>
								<p class="aj">Breakfast at hotel, morning transfer to railway station go to Shanghai by Bullet train (High Speed Train Ride). Arrive Shanghai pick up, Acrobatic Show in the evening. Indian dinner at local Indian restaurant.<br />
Breakfast + Indian Lunch+ Indian Dinner at 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> Shanghai
								</p>
								<p class="aj">Breakfast at hotel. Morning visit the Shanghai Museum which is the largest museum of ancient Chinese art in Shanghai. The museum includes artifacts demonstrating ancient wisdom and philosophy, the museum is divided into eleven galleries and three exhibition halls. Later visit the People Square and Nanjing Road for shopping, then go to the silk shop. later visit the lovely old Yuyuan Garden-outside look nine zig zag bridge with golden fish pond, bridges and pavilions, Jude Buddha temple , Xintiandi, Then we step onto Yu Market.<br />
Breakfast + Indian Lunch+ Indian Dinner at 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> Shanghai
								</p>
								<p class="aj">Breakfast at the Hotel, after breakfast proceeds to visit TV tower level 2, Maglev Train ride (World’s fastest Train) We will explore the Bund and century street and century park in the evening , Cultural program: Huangpu River Cruise.<br />
Breakfast + Indian Lunch+ Indian Dinner at 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> Shanghai
								</p>
								<p class="aj">Breakfast at hotel, Proceed to Shanghai city tour and Yu garden and pearl factor after that transfer to airport to get Int'l flight,<br />
Breakfast + Indian Lunch+ Indian Dinner at Indian Restaurant.</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>
																		<li>Transfers</li>
																		<li>Entry Tickets</li>
															</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Any increase in Airfare.</li><li>
Any increase in Airport Taxes, Fuel Surcharge.</li><li>
Meals are preset & Choice of menu is not available.</li><li>
All Kinds of tips to drivers, guides, representative etc.</li><li>
Any expenses of personal nature such a laundry expenses, wine, mineral water, food and drinks other than mentioned in the regular menu.</li><li>
Any services not specified in the inclusion Activities of any kind are excluded in the package.</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. ~^#^~						
    	<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">Occupancy/Prices</td>
				<td class="headHr p5px b">Comfort Class</td>
			</tr>
			<tr>
				<td class="headVr p5px">Single Occupancy</td>
				<td class="data p5px">Rs. 95,800/-</td>
			</tr>
			<tr>
				<td class="headVr p5px">Double Occupancy</td>
				<td class="data p5px">Rs. 86,000/-</td>
			</tr>
			<tr>
				<td class="headVr p5px">Triple Occupancy</td>
				<td class="data p5px">Rs. 84,800/-</td>
			</tr>
			<tr>
				<td class="headVr p5px">Child With Bed ( 2 - 11 Yrs)</td>
				<td class="data p5px">Rs. 76,600/-</td>
			</tr>
			<tr>
				<td class="headVr p5px">Child Without Bed ( 2 - 11 Yrs)</td>
				<td class="data p5px">Rs. 74,200/-</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Flight Details :-</p>
    	<div class="otherDetails aj">Note - The Flight timings or schedule is subject to change as per the airlines operational feasibility</div><br>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Flight Details</td>
				<td class="headHr p5px b">Flight No.</td>
				<td class="headHr p5px b">From - Via - To</td>
				<td class="headHr p5px b">Departure</td>
				<td class="headHr p5px b">Arrival</td>
			</tr>
			<tr>
				<td class="headVr p5px">India - China</td>
				<td class="data p5px">CX 632 / KA 908</td>
				<td class="data p5px">Chennai - Hong kong - Beijing</td>
				<td class="data p5px">01:40 HRS</td>
				<td class="data p5px">15:15 HRS</td>
			</tr>
			<tr>
				<td class="headVr p5px">China - India</td>
				<td class="data p5px">CX 369 / CX 631</td>
				<td class="data p5px">Shanghai - Hong kong - Chennai</td>
				<td class="data p5px">17:35 HRS</td>
				<td class="data p5px">23:55 HRS</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Best of China</p>						</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="https://www.grandindiatrip.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Best of China 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="58663"/>
						</form>
						</div>
						
						";i:1;s:57:"Book Best of China Tour - 6 Nights / 7 Days Tour Packages";i:2;s:123:"book best of china tour - 6 nights / 7 days tour packages, forts and palaces tour packages, beijing, shanghai tour packages";i:3;s:182:"Book Best of China Tour - 6 Nights / 7 Days tour packages from Grand India Tours & Travels - Get attractive 6 Nights / 7 Days Forts and Palaces  tour packages for  Beijing, Shanghai.";i:4;s:7893:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Beijing, Shanghai"        
		                 },
		      "description": "<b>Description:</b>
Everything about China is larger than life and so is the experience that it bestows on travellers, who come to explore this gigantic Asian country. Today, people around the world know China for its economic growth but the country has more to its fame and name. It is a marvellous land with diverse geographical realms and culture that dates back to 17th century BC. A trip to China offers a wonderful chance to experience unique combination of crowded metropolitan cities and rural landscapes that flaunt unimaginable natural beauty. The country is home to the world's largest population and also a plethora of heritage sites. The mainland China has some highly cosmopolitan cities, among which Beijing- the capital, holds a supreme status. Xian, a former capital and the oldest of all the cities in China, is another place that attracts visitors on a China trip. Ten important dynasties of the region, including Tang and Han, originated from this history-rich city. Other major cities that tourists must include in their itinerary are Hangzhou, Kunming, Nanjing, Suzhou (popularly known as 'Venice of the East'), Guilin (known for scenic landscapes and picturesque mountains), Shanghai (major commercial centre and the country's largest city) and Guangzhou. There are modern entertainment facilities in China's metropolitan cities; however, the real tourist attractions are the heritage sites. One will be amazed to know that China is the third country in the list of countries with most heritage sites. The Great Wall of China tops the list of historic sites in the region and is the longest man-made structure till date. The Terracotta Army is another major tourist attraction in Xian and depicts a necropolis of terracotta sculptures built during the reign of Qin Shi Huang, the first Emperor of China. Other sites that make China a place worth-visiting are the Forbidden City, Mogao Caves, Peking Man, Ancient City of Ping Yao, Chengjiang Fossil Site and the capital cities and tombs of the Ancient Koguryo Kingdom. Holiday in China would be incomplete if one doesn't include the blessed-by-nature scenic spots. The Jiuzhaigou Valley is quite famous for its colourful lakes, snow-clad peaks and numerous waterfalls. Other natural sites for tourists to see are Mount Taishan, Mount Huangshan, Mount Emei scenic area featuring the famous Leshan Giant Buddha sculpture, and Sichuan Giant Panda Sanctuaries. One can avail an exciting China tour package from Yatra.com to travel around the country in a convenient and of course, a cost-effective manner.
Route :  Chennai - Beijing - Shanghai - Chennai
IRCTC Flight Packages
Traveling Mode - By Flight
Station/Departure Time	- Chennai airport at 01:40 hrs.
Class - Comfort
Tour Date - 18/June/2016
Hotel Name
Beijing - J Hotel / Similar
Shanghai - Ramada Hotel / Similarocuments required for VISA: 
Original passport with minimum 6 months validity from the date of travel.
2 white back ground recent passport size photo.
Total Seats:- 30 
Note: we will not encourage on arrival visa.
Kindly ensure that your passport is valid for minimum 6 months beyond the stay, ECNR/POE formalities completed, etc.
Two passport size photographs and copy of passport & pan card in full duly signed by the customer need to be submitted to IRCTC within three days of the booking.
Above rates are subject to availability.
Cancellation charges as per company policy.
Room categories in all packages are the base category rooms unless stated otherwise.
Final confirmation in the proposed hotels is subject to the availability at the time of booking, else similar category hotel will be provided.
Please reach the airport 3 hours before the departure of the flight. IRCTC will not responsible for missing of flights by the guest.
In flight food and beverages are on chargeable basis.
Kindly reconfirm the departure terminal and the flight schedule from the airline before leaving for the airport.
Web check in is not possible in our group packages.
Transfers and Sightseeing tours are on SIC (seat in coach) / shared basis by A/C vehicle.
Arrival / departure transfers & sightseeing tours shall be provided as per schedule.
However this may require you to wait at the airport for short duration until all the guests arriving at that time exit the airport.
The request for an adjacent or an adjoining room will be on subject to availability.
It is mandatory to carry the age proof of children (02 to 11 yrs) and infant (below 02yrs) as well along with other travel documents. Child above than 11 yrs shall be considered for an adult cost.
In airline no seat is provided to Infant.
Room allocation (Twin bed / Double bed) is at the discretion of the hotel. The check in and check out time of the hotel is 12 to 12 noon. Numbers of meals are always corresponding to the number of nights booked. Breakfast is not provided on the day of arrival.
In hotels for an extra Adult / Child either Rollaway bed or mattress shall be provided.
For early check in and late check out the payment is to be settled directly by the guest.
Hotel has the right to claim the damages incurred by any of the guest.
The guests are requested to take care of their personal belongings carefully and avoid leaving them unattended.
The airfares and taxes are calculated as on a mentioned date and any increase in the Taxes or airfares will be borne by the customer.
For any change in Flight Timings/diversions, Flight cancellation from the airline IRCTC will not be responsible and if it further affects the Sightseeing/Itinerary client need to accommodate accordingly.
Cost of additional services availed by the guest which are not part of our package inclusions are to be settled directly at the hotel.
Buffet/Fixed meal will be provided at fixed venue decided by the hotel.
You are kindly requested to check the perfect buffet timings at the time of check in at the hotel. Once the buffet time is over the hotel might ask you to pay for your meals.
IRCTC request you that before finalizing the tour with us kindly go through the website of the hotels and read the reviews.
Package cost is calculated on lowest class Air Fare. Any increase in air fare or air port taxes has to be borne by the client.
Any Itinerary posted on the website is only a proposed holiday outline.
In case there is any change in price the same will be communicated to yourself and only after your confirmation, we will proceed further.
There will be no refund for un-utilized services.
The package Price is subject to change without prior notice.
Above tour prices are subject to change in the event of increase in hotel room rates levy by the hotel especially during peak season / holiday surcharge and major events/ fairs and convention.
Passenger should get full briefing about the tour from IRCTC before/after the booking to avoid any confusion.
IRCTC is not liable for personnel expenses, boating, porterage, theft, accidents etc.
Any other terms and conditions applied as may be decided by IRCTC at any point of time.Any increase in Airfare.
Any increase in Airport Taxes, Fuel Surcharge.
Meals are preset & Choice of menu is not available.
All Kinds of tips to drivers, guides, representative etc.
Any expenses of personal nature such a laundry expenses, wine, mineral water, food and drinks other than mentioned in the regular menu.
Any services not specified in the inclusion Activities of any kind are excluded in the package.",
		      "name": "Best of China Tour",
		      "telephone": "+91-9415285186"
		    }
		    </script>
			";i:5;N;}