a:6:{i:0;s:25740:"				<div class="h1"><h1>Golden Triangle Tour Extensions with Varanasi</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>Golden Triangle Tour Extensions with Varanasi</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">Golden Triangle Tour</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Duration </td>
						<td class="p5px pl0px vat">
						8 Nights / 9 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">New Delhi, Jaipur, Agra, Varanasi</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						USD 875 Per Person						</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="Golden Triangle Tour Extensions with Varanasi - 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="59377"/>
						</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/113314.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/113314.jpg"  width="150" height="150"    alt="Golden Triangle Tour Extensions with Varanasi" title="Golden Triangle Tour Extensions with Varanasi" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					Tourist Attractions in Delhi<br />
The city of Delhi is full of fascinating places to visit and see. Some of the main ones are as follows -<br />
<br />
Qutab Minar Complex: The construction of the Qutab Minar was started by Qutab-ud-din Aibak, the first Muslim ruler of Delhi in 1200 AD. He could finish only the basement and later his successor, Iltutmish, added three more storeys. The fifth and final storey was constructed by Firoz Shah Tughlak in 1368.<br />
<br />
Red Fort: The foundation of the Red Fort, so named after its red stone, was laid in 1618 when the Mughal Emperor, Shah Jahan, shifted to Delhi after ruling from Agra for 11 years. Rich silk from China and velvet from Turkey were used to drape the main halls of the palace when it was inaugurated in 1647.<br />
<br />
Purana Quila: The fort is said to be constructed on the historic site of Indraprastha (900BC) by Humayun and Sher Shah.<br />
<br />
Jama Masjid: Built by the Mughal Emperor Shah Jahan in 1650, more than 5,000 men worked for six years to complete this largest mosque in India.<br />
<br />
Safdarjang's Tomb: Built by Nawab Shauja-ud-Daula in 1753 to preserve the remains of his father, this tomb has been described as “the last flicker in the lamp of Mughal architecture’.<br />
<br />
India Gate: Designed by Sir Edwin Lutyens and completed in 1931 the gate is 160 ft. high an has a 138 ft arch. The Gate also houses the ‘Eternal Flame’, that burns in memory of Indian soldiers who laid down their lives in <br />
World War I.<br />
<br />
Rashtrapati Bhawan: Formerly the Vice-regal Lodge, the building is the presidential palace. It was completed in 1929 at a cost of 12,53,000 pound sterling and has 340 rooms.<br />
<br />
Rajghat: The place where the remains of Mahatma Gandhi have been placed, set amidst exotic trees and fountains.<br />
<br />
Purana Quila: The old fort that was built by Humayun and Sher Shah on the historic site of Indraprastha (900BC).<br />
<br />
Jantar Mantar: The first of five observatories built by Sawai Jia Singh II of Jaipur (1699-1743), the structure has huge masonry instruments.<br />
<br />
Humanyu'sTomb: This was built by the emperor's grieving widow, Haji Begum, in 1565 AD. Made with red sandstone it marks the beginning of a new ornate architectural style that reached its peak in the Taj Mahal of Agra.<br />
<br />
Delhi also offers visitors an incredible range of shopping options specially handicrafts like carpets, jewellary, silk, and cotton that are synonymous with India. Each state has its own representative outlet, apart from which you can buy items at different prices depending on quality and outlet.<br />
<br />
In addition to this the city has numerous options in gardens, places of worship, food outlets, excursions, and culture. In recent times Delhi has developed into a real metropolitan. All international brands are easily available, global cuisine is a ready option and there is something to suit every pocket. Very few places in this world can simultaneously be described as modern & traditional, historical & new, contemporary & ancient. Delhi is one of them!<br />
<br />
Tourist Attractions in Agra<br />
The most popular sight in Agra is undoubtedly the Taj Mahal, built by Emperor Shah Jahan in memory of his wife Mumtaz Mahal. An essential sight for all visitors to India, the Taj is one of the most achingly beautiful architectural achievements in the world, and is considered to be a symbol of enduring love. Shrouded in white marble the sheer elegance, purity and sentiment that are an integral part of the monument have touched the hearts of people from all corners of the world.<br />
<br />
In addition to this, the city is full of other interesting monuments and architectural specimens as well. To begin with there is the Agra Fort that was constructed by Emperor Akabar in 1565 A.D and includes many other buildings like the Moti Masjid and Musanman Burj, where Shah Jahan is believed to have been imprisoned and died.<br />
<br />
Then there is Itmad-ud Dual, the tomb of Mirza Ghiyas Beg, Emperor Jehangir's father-in-law. It was built by Empress Noor Jehan and is exquisitely decorated with pietra dura inlay and latticed marble screens and is another fine example of Mughal architecture.<br />
<br />
There is also the Chini Ka Roza which is the tomb of Afzal Khan, a Persian poet and minister in the court of Emperor Shah Jahan. The name of this monument is inspired by the bright glazed tiles that have been used to decorate it and enhance its beauty.<br />
<br />
Around 10 km from Agra, lies Sikandra, the mausoleum of Emperor Akbar. This structure offers a unique combination of styles borrowing from Hindu, Christian, Islamic, Buddhist and even Jain architectural conventions.<br />
<br />
Then there is the famous Fatehpur Sikri, the location where Emperor Akbar began the construction of his new Capital city following the fulfilling of a prophecy of being blessed by a male heir. Fatehpur Sikri also houses the tomb of the Sufi Saint Salim Chisti of Sikri who had made the prophecy. The site is well known for its spiritual atmosphere and qawaalis and offers the perfect retreat into a place where time stands still.<br />
<br />
Other than its great architectural richness, Agra is also well known for certain savories like petha that are particular to the city. Its varied arts and crafts include leatherwork, brass work, a range of precious and semi-precious stone jewellary, traditional gold embroidery, and marble inlay work. There are shopping areas to be found in every nook and corner with the indigenous markets selling things at lower prices than the state emporiums.<br />
<br />
The climate in Agra is usually extreme and the best time to visit the city is between October to March. The languages spoken here are Hindi, English &Urdu The city of Agra offers such a rich, diverse and fascinating mix of culture, tradition, language and expression that most people who come here once end up returning to indulge in its special flavour. While there are beautiful places all over the world no one can argue with the sheer magic that the Taj exudes making it an unforgettable and cherished image forever.<br />
<br />
Tourist Attractions in Jaipur<br />
There is no dearth of things that one can do in Jaipur. To begin with there is sight-seeing, and the city offers an incredible array of historical sites. Right from forts like the Amer Fort, Jaigarh Fort, and Nahargarh Fort, to the City Palace to other monuments like the Jantar Mantar and Hawa Mahal, Jaipur’s rich history offers innumerable opportunities to catch a glimpse into the past.<br />
<br />
Other Places like the Jal Mahal, the Royal Cenotaphs, Statue circle , Galta, and Ramgarh, also afford similar opportunities.<br />
<br />
Apart from sight-seeing, Jaipur is a shopper’s paradise. The founders and builders of the city made sure to provide enough space and facilities that enabled craftsmen to produce and market handicrafts easily. Entire streets were set aside for such commercial activity and much of the city’s handicrafts became famous all over the country and remain to be so even today.<br />
<br />
One of the things that Jaipur is most known for is jewellary. Be it precious or semi-precious stones, diamonds, emeralds or topaz, this is a highly active market and has excelled in related areas like the cutting, polishing and setting of these stones. In addition to this there is the Jaipur brasswork –lacqured and carved- that is well known. Camel leather is another popular object and lampshades made of it adorn rooms all over the country.<br />
<br />
The Jaipuri craftsmen/women are incredibly talented in intricate handiwork as can be seen in the enameled minakari and kundan work they do an which is a specialty of the city.<br />
<br />
In the area of textiles one can find the traditional shanganari , tie and dye and bagru prints that one cannot help but admire for their colors, evenness and ethnicity.<br />
<br />
One of the best features of jaipur is that it has a number of fairs (elephant fair) and festivals like Gangaur and Teej that are unique. It is a worthwhile experience to be in Jaipur during this time and to see the entire city come alive in celebrating them with colour, abandon and festivities.<br />
<br />
Jaipur is one of the most well-connected cities in the country, largely due to the fact that it is such a huge tourist attraction. A special luxury train called the ‘Palace on Wheels’ runs once a week from Delhi from September to April. The train, which goes on round trip of the State of Rjasthan makes its first stop in Jaipur. In addition to this there are numerous other buses and trains (luxury as well as ordinary) available.<br />
<br />
Although the whole if Rajasthan is known for its beauty and immense cultural appeal, Jaipur is special because of its double capacity of being modern as well as traditional. Being the capital it is up to date with all the amenities of a urban center and has still managed to retain its original flavor of folk richness. Even today the city of Jaipur can help you to escape into an ethereal past and experience a richness of color, culture and history.<br />
<br />
As Varanasi lies on the banks of the mighty river Ganga, the two have become synonymous. Varanasi's ghats are extremely popular all around the globe. The Assi Ghat is among the most famous ghats of India. Varanasi is also famous as one of the oldest inhabited cities in the world. Check out the places to visit in Varanasi.<br />
<br />
ALSO SEE Top 6 Ghats of Varanasi you must visit <br />
<br />
6 most beautiful photographs of India’s oldest continuously inhabited cities! <br />
<br />
4 films that perfectly capture the spirit of Varanasi! <br />
<br />
All<br />
Cultural<br />
Temples<br />
Historical<br />
Architecture<br />
Religious<br />
Kashi Vishwanath temple<br />
Kashi Vishwanath temple<br />
Kashi Vishwanath, a manifestation of Lord Shiva, is the patron deity of Varanasi. The idol is a jyotirlinga, one of the 12 jyotirlingas in India. The Kashi Vishwanath…<br />
Cultural Temples<br />
Bharat Kala Bhavan<br />
Bharat Kala Bhavan<br />
Bharat Kala Bhavan is located inside the Banaras Hindu University campus. It displays India’s heritage and preserves the past of the nation. It is divided in several sections…<br />
Historical<br />
Banaras Hindu University<br />
Banaras Hindu University<br />
Banaras Hindu University is one of the largest universities in the world and a prime attraction in Varanasi. It was founded by Pandit Mohan Malviya in 1916 and…<br />
Architecture Historical<br />
Assi Ghat<br />
Assi Ghat<br />
Assi Ghat is the southern most ghat in Varanasi. It is located at the confluence of Ganga and Assi rivers. In the evenings, there is an aarti at…<br />
Religious<br />
Ramnagar Fort<br />
Ramnagar Fort<br />
Located near Ganges river on its eastern bank, Ramnagar fort is a structure in Varanasi built in 1750 by Kashi Naresh Raja Balwant Singh. The architecture of this…<br />
Architecture Historical<br />
Dashashwamedh Ghat<br />
Dashashwamedh Ghat<br />
Dashashwamedh Ghat is one of the oldest and most important ghats in Varanasi. In the early 16th century when the Marathas were ruling over the region, th3ey built several.Any meals other than those specified.<br />
Expenses of personal nature such as tips, telephone calls, laundry, liquor etc.<br />
Entrance fees during sightseeing.<br />
Any other item not specified.<br />
International airfare.<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 Delhi
								</p>
								<p class="aj">On arrival at Delhi airport or railway station, our representative will meet you to pick you up and transfer to your hotel. Rest of the day is at your leisure. Stay overnight at the hotel in Delhi.</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> City Tour of Delhi
								</p>
								<p class="aj">This morning after breakfast first you will visit old Delhi. The Raj Ghat, Red fort & Jama Masjid are important places to visit, you may also visit Chandni Chowk, spice market etc. Later on proceed to visit the New Delhi. The Qutub Minar, tallest stone tower in India, imposing India Gate and the Rastrapathi Bhawan, Laxmi Narayan Temple, Lotus Temple and, newly built Akshardham temple are of much significance. By evening return to your hotel for overnight stay.</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> Delhi to Jaipur
								</p>
								<p class="aj">This morning after breakfast you will drive to the pink city of Jaipur, On arrival check into your hotel and rest of the day is at leisure. Stay overnight at hotel in Jaipur.</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> Jaipur City Tour
								</p>
								<p class="aj">This morning after breakfast visit the Amber fort, built in 16th century, enjoy an elephant ride at Amber. Drive past the Hawa Mahal-a Palace of winds. In the afternoon you will visit the city palace and museum, walk to adjacent Jantar Mantar an astronomical observatory. Rest of the evening is at leisure. Stay overnight at hotel in Jaipur.</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> Jaipur to Agra
								</p>
								<p class="aj">This morning after breakfast you will drive to Mughal city Agra and check into your hotel. Enroute you will visit the Fatehpur Sikri, the deserted red sandstone city built by the Mughal Emperor Akbar. Rest of the day is free at your leisure. Overnight at hotel.</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> Agra-Visit to Tajmahal & Overnight train to Varanasi
								</p>
								<p class="aj">This Morning after breakfast visit the Agra fort, built by the great Emperor Akbar, and the famous Taj Mahal-the symbol of love, built by Emperor Shah Jahan in memory of his wife Mumtaz Mahal. You may also visit Dayal Bagh. By evening you will be transferred to board the train to Varanasi. Overnight in Train.</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> Varanasi City Tour
								</p>
								<p class="aj">On arrival at Varanasi, pick up and transfer to Hotel. This afternoon visit the Bharat Mata Temple, Durga temple, Tulsi Manas mandir, Banaras Hindu University which has an art gallery, Kashi Vishwanath Temple etc. Overnight at Hotel.</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> Boat Ride & visit to Sarnath
								</p>
								<p class="aj">Early morning boat excursion on the holy river Ganges to see the bathing ghats and cremation site. Watching people bathing and worshiping at the ghats is one of the most extraordinary experiences of a visit to India. This afternoon visit Sarnath, the Buddhist city, where Lord Buddha gave his first sermon. Visit the ruins, the Stupa, the Buddhist temple and the museum. Return to hotel for overnight stay.</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 9:</b> Varanasi to Delhi by Flight & Transfer to International Airport
								</p>
								<p class="aj">Today you will be transferred to Airport to take a flight to Delhi. On arrival at Delhi Airport assistance in transferring to International Airport to board your onward flight.</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>Transport</li>
															</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Any meals other than those specified.</li><li>
Expenses of personal nature such as tips, telephone calls, laundry, liquor etc.</li><li>
Entrance fees during sightseeing.</li><li>
Any other item not specified.</li><li>
International airfare.</li></ul><br />
												<p class="large b mb5px dif">Departure Cities with rates :</p>Hotels to be provided:
City

Number of
Nights

Economy Hotels 
Budget Hotels

Deluxe Hotels 
3 to 4 Star

Luxury Hotels 
5 Star

Delhi

2

Hotel Arpit Palace

Hotel Singh Sons

Hotel The Park

Jaipur

2

Hotel Chandragupta

Hotel Mandawa Haveli

Hotel Clarks Amer

Agra

1

Hotel Royale Residency

Howard Park Plaza

Hotel Clarks Shiraz

Varanasi

2

Hotel India

Hotel Hindustan International

Hotel Taj Ganges<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</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="data p5px">Package Category</td>
				<td class="data p5px">Economy Package</td>
				<td class="data p5px">Deluxe Package</td>
				<td class="data p5px">Luxury Package</td>
			</tr>
			<tr>
				<td class="data p5px">Price for a single Person traveling alone</td>
				<td class="data p5px">US$ 875</td>
				<td class="data p5px">US$ 1075</td>
				<td class="data p5px">US$ 1775</td>
			</tr>
			<tr>
				<td class="data p5px">Price per person on twin sharing basis</td>
				<td class="data p5px">US$ 545</td>
				<td class="data p5px">US$ 695</td>
				<td class="data p5px">US$ 1145</td>
			</tr>
			<tr>
				<td class="data p5px">Group Rates</td>
				<td class="data p5px">On request</td>
				<td class="data p5px">On request</td>
				<td class="data p5px">On request</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Package Cost</p>
    	<div class="otherDetails aj">Valid from 1st April 2016 to 30th September 2016</div><br>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="data p5px">Package Category</td>
				<td class="data p5px">Economy Package</td>
				<td class="data p5px">Deluxe Package</td>
				<td class="data p5px">Luxury Package</td>
			</tr>
			<tr>
				<td class="data p5px">Price for a single Person traveling alone</td>
				<td class="data p5px">US$ 775</td>
				<td class="data p5px">US$ 995</td>
				<td class="data p5px">US$ 1695</td>
			</tr>
			<tr>
				<td class="data p5px">Price per person on twin sharing basis</td>
				<td class="data p5px">US$ 495</td>
				<td class="data p5px">US$ 595</td>
				<td class="data p5px">US$ 1045</td>
			</tr>
			<tr>
				<td class="data p5px">Group Rates</td>
				<td class="data p5px">On request</td>
				<td class="data p5px">On request</td>
				<td class="data p5px">On request</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Hotel Details</p>
    	<div class="otherDetails aj">Hotels to be provided:<br>
City            Number of Nights  Economy Hotels         Budget Hotels            Deluxe Hotels           Luxury Hotels<br>
Delhi           3 to 4 Star       Hotel Arpit Palace     Hotel Singh Sons             Hotel The Park<br>
                5 Star 2<br>
Jaipur              2              Hotel Chandragupta     Hotel Mandawa Haveli         Hotel Clarks Amer <br>
<br>
Agra                1             Hotel Royale Residency Howard Park Plaza            Hotel Clarks Shiraz<br>
<br>
Varanasi            2              Hotel India            Hotel Hindustan International Hotel Taj Ganges</div><br>						</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="Golden Triangle Tour Extensions with Varanasi - 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="59377"/>
						</form>
						</div>
						
						";i:1;s:84:"Book Golden Triangle Tour Extensions with Varanasi - 8 Nights / 9 Days Tour Packages";i:2;s:157:"book golden triangle tour extensions with varanasi - 8 nights / 9 days tour packages, heritage tour packages, new delhi, jaipur, agra, varanasi tour packages";i:3;s:216:"Book Golden Triangle Tour Extensions with Varanasi - 8 Nights / 9 Days tour packages from Grand India Tours & Travels - Get attractive 8 Nights / 9 Days Heritage  tour packages for  New Delhi, Jaipur, Agra, Varanasi.";i:4;s:11484:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "New Delhi, Jaipur, Agra, Varanasi"        
		                 },
		      "description": "Tourist Attractions in Delhi
The city of Delhi is full of fascinating places to visit and see. Some of the main ones are as follows -

Qutab Minar Complex: The construction of the Qutab Minar was started by Qutab-ud-din Aibak, the first Muslim ruler of Delhi in 1200 AD. He could finish only the basement and later his successor, Iltutmish, added three more storeys. The fifth and final storey was constructed by Firoz Shah Tughlak in 1368.

Red Fort: The foundation of the Red Fort, so named after its red stone, was laid in 1618 when the Mughal Emperor, Shah Jahan, shifted to Delhi after ruling from Agra for 11 years. Rich silk from China and velvet from Turkey were used to drape the main halls of the palace when it was inaugurated in 1647.

Purana Quila: The fort is said to be constructed on the historic site of Indraprastha (900BC) by Humayun and Sher Shah.

Jama Masjid: Built by the Mughal Emperor Shah Jahan in 1650, more than 5,000 men worked for six years to complete this largest mosque in India.

Safdarjang's Tomb: Built by Nawab Shauja-ud-Daula in 1753 to preserve the remains of his father, this tomb has been described as “the last flicker in the lamp of Mughal architecture’.

India Gate: Designed by Sir Edwin Lutyens and completed in 1931 the gate is 160 ft. high an has a 138 ft arch. The Gate also houses the ‘Eternal Flame’, that burns in memory of Indian soldiers who laid down their lives in 
World War I.

Rashtrapati Bhawan: Formerly the Vice-regal Lodge, the building is the presidential palace. It was completed in 1929 at a cost of 12,53,000 pound sterling and has 340 rooms.

Rajghat: The place where the remains of Mahatma Gandhi have been placed, set amidst exotic trees and fountains.

Purana Quila: The old fort that was built by Humayun and Sher Shah on the historic site of Indraprastha (900BC).

Jantar Mantar: The first of five observatories built by Sawai Jia Singh II of Jaipur (1699-1743), the structure has huge masonry instruments.

Humanyu'sTomb: This was built by the emperor's grieving widow, Haji Begum, in 1565 AD. Made with red sandstone it marks the beginning of a new ornate architectural style that reached its peak in the Taj Mahal of Agra.

Delhi also offers visitors an incredible range of shopping options specially handicrafts like carpets, jewellary, silk, and cotton that are synonymous with India. Each state has its own representative outlet, apart from which you can buy items at different prices depending on quality and outlet.

In addition to this the city has numerous options in gardens, places of worship, food outlets, excursions, and culture. In recent times Delhi has developed into a real metropolitan. All international brands are easily available, global cuisine is a ready option and there is something to suit every pocket. Very few places in this world can simultaneously be described as modern & traditional, historical & new, contemporary & ancient. Delhi is one of them!

Tourist Attractions in Agra
The most popular sight in Agra is undoubtedly the Taj Mahal, built by Emperor Shah Jahan in memory of his wife Mumtaz Mahal. An essential sight for all visitors to India, the Taj is one of the most achingly beautiful architectural achievements in the world, and is considered to be a symbol of enduring love. Shrouded in white marble the sheer elegance, purity and sentiment that are an integral part of the monument have touched the hearts of people from all corners of the world.

In addition to this, the city is full of other interesting monuments and architectural specimens as well. To begin with there is the Agra Fort that was constructed by Emperor Akabar in 1565 A.D and includes many other buildings like the Moti Masjid and Musanman Burj, where Shah Jahan is believed to have been imprisoned and died.

Then there is Itmad-ud Dual, the tomb of Mirza Ghiyas Beg, Emperor Jehangir's father-in-law. It was built by Empress Noor Jehan and is exquisitely decorated with pietra dura inlay and latticed marble screens and is another fine example of Mughal architecture.

There is also the Chini Ka Roza which is the tomb of Afzal Khan, a Persian poet and minister in the court of Emperor Shah Jahan. The name of this monument is inspired by the bright glazed tiles that have been used to decorate it and enhance its beauty.

Around 10 km from Agra, lies Sikandra, the mausoleum of Emperor Akbar. This structure offers a unique combination of styles borrowing from Hindu, Christian, Islamic, Buddhist and even Jain architectural conventions.

Then there is the famous Fatehpur Sikri, the location where Emperor Akbar began the construction of his new Capital city following the fulfilling of a prophecy of being blessed by a male heir. Fatehpur Sikri also houses the tomb of the Sufi Saint Salim Chisti of Sikri who had made the prophecy. The site is well known for its spiritual atmosphere and qawaalis and offers the perfect retreat into a place where time stands still.

Other than its great architectural richness, Agra is also well known for certain savories like petha that are particular to the city. Its varied arts and crafts include leatherwork, brass work, a range of precious and semi-precious stone jewellary, traditional gold embroidery, and marble inlay work. There are shopping areas to be found in every nook and corner with the indigenous markets selling things at lower prices than the state emporiums.

The climate in Agra is usually extreme and the best time to visit the city is between October to March. The languages spoken here are Hindi, English &Urdu The city of Agra offers such a rich, diverse and fascinating mix of culture, tradition, language and expression that most people who come here once end up returning to indulge in its special flavour. While there are beautiful places all over the world no one can argue with the sheer magic that the Taj exudes making it an unforgettable and cherished image forever.

Tourist Attractions in Jaipur
There is no dearth of things that one can do in Jaipur. To begin with there is sight-seeing, and the city offers an incredible array of historical sites. Right from forts like the Amer Fort, Jaigarh Fort, and Nahargarh Fort, to the City Palace to other monuments like the Jantar Mantar and Hawa Mahal, Jaipur’s rich history offers innumerable opportunities to catch a glimpse into the past.

Other Places like the Jal Mahal, the Royal Cenotaphs, Statue circle , Galta, and Ramgarh, also afford similar opportunities.

Apart from sight-seeing, Jaipur is a shopper’s paradise. The founders and builders of the city made sure to provide enough space and facilities that enabled craftsmen to produce and market handicrafts easily. Entire streets were set aside for such commercial activity and much of the city’s handicrafts became famous all over the country and remain to be so even today.

One of the things that Jaipur is most known for is jewellary. Be it precious or semi-precious stones, diamonds, emeralds or topaz, this is a highly active market and has excelled in related areas like the cutting, polishing and setting of these stones. In addition to this there is the Jaipur brasswork –lacqured and carved- that is well known. Camel leather is another popular object and lampshades made of it adorn rooms all over the country.

The Jaipuri craftsmen/women are incredibly talented in intricate handiwork as can be seen in the enameled minakari and kundan work they do an which is a specialty of the city.

In the area of textiles one can find the traditional shanganari , tie and dye and bagru prints that one cannot help but admire for their colors, evenness and ethnicity.

One of the best features of jaipur is that it has a number of fairs (elephant fair) and festivals like Gangaur and Teej that are unique. It is a worthwhile experience to be in Jaipur during this time and to see the entire city come alive in celebrating them with colour, abandon and festivities.

Jaipur is one of the most well-connected cities in the country, largely due to the fact that it is such a huge tourist attraction. A special luxury train called the ‘Palace on Wheels’ runs once a week from Delhi from September to April. The train, which goes on round trip of the State of Rjasthan makes its first stop in Jaipur. In addition to this there are numerous other buses and trains (luxury as well as ordinary) available.

Although the whole if Rajasthan is known for its beauty and immense cultural appeal, Jaipur is special because of its double capacity of being modern as well as traditional. Being the capital it is up to date with all the amenities of a urban center and has still managed to retain its original flavor of folk richness. Even today the city of Jaipur can help you to escape into an ethereal past and experience a richness of color, culture and history.

As Varanasi lies on the banks of the mighty river Ganga, the two have become synonymous. Varanasi's ghats are extremely popular all around the globe. The Assi Ghat is among the most famous ghats of India. Varanasi is also famous as one of the oldest inhabited cities in the world. Check out the places to visit in Varanasi.

ALSO SEE Top 6 Ghats of Varanasi you must visit 

6 most beautiful photographs of India’s oldest continuously inhabited cities! 

4 films that perfectly capture the spirit of Varanasi! 

All
Cultural
Temples
Historical
Architecture
Religious
Kashi Vishwanath temple
Kashi Vishwanath temple
Kashi Vishwanath, a manifestation of Lord Shiva, is the patron deity of Varanasi. The idol is a jyotirlinga, one of the 12 jyotirlingas in India. The Kashi Vishwanath…
Cultural Temples
Bharat Kala Bhavan
Bharat Kala Bhavan
Bharat Kala Bhavan is located inside the Banaras Hindu University campus. It displays India’s heritage and preserves the past of the nation. It is divided in several sections…
Historical
Banaras Hindu University
Banaras Hindu University
Banaras Hindu University is one of the largest universities in the world and a prime attraction in Varanasi. It was founded by Pandit Mohan Malviya in 1916 and…
Architecture Historical
Assi Ghat
Assi Ghat
Assi Ghat is the southern most ghat in Varanasi. It is located at the confluence of Ganga and Assi rivers. In the evenings, there is an aarti at…
Religious
Ramnagar Fort
Ramnagar Fort
Located near Ganges river on its eastern bank, Ramnagar fort is a structure in Varanasi built in 1750 by Kashi Naresh Raja Balwant Singh. The architecture of this…
Architecture Historical
Dashashwamedh Ghat
Dashashwamedh Ghat
Dashashwamedh Ghat is one of the oldest and most important ghats in Varanasi. In the early 16th century when the Marathas were ruling over the region, th3ey built several.Any meals other than those specified.
Expenses of personal nature such as tips, telephone calls, laundry, liquor etc.
Entrance fees during sightseeing.
Any other item not specified.
International airfare.",
		      "name": "Golden Triangle Tour Extensions with Varanasi",
		      "telephone": "+91-9415285186"
		    }
		    </script>
			";i:5;N;}