a:6:{i:0;s:13861:"				<div class="h1"><h1>Tour Package for Bodhgaya,Rajgir & Nalanda</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.southindiantours.co.in/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.southindiantours.co.in/travel-packages.htm" title="Travel Packages">Travel Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Tour Package for Bodhgaya,Rajgir & Nalanda</p>
				<br />
				
									<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>
					
					<table class="w100 formTable imgWidth">
					<tr>
					
											<td class="p10px vat imgWidth150 w150px">
						<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_14/407812/171810.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/407812/171810.jpg"  width="150" height="150"    alt="Tour Package for Bodhgaya,Rajgir & Nalanda" title="Tour Package for Bodhgaya,Rajgir & Nalanda" /></a></p></div></li>
															</ul>
						</div>
						</td>
											
					<td class="p10px">
											<p class="mb5px"><b>Duration :</b> 
						3 Nights / 4 Days 
						</p>
												<p class="mb5px"><b>Destination Covered :</b> Patna, Rajgir</p>
												<p><b>Price (Starting From) :</b>						
						INR 24460 Per Person						</p>
												<br />
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.southindiantours.co.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Tour Package for Bodhgaya,Rajgir & Nalanda - Tour Package"/>
						<input type="hidden" name="allocate_type" value="tour"/>
						<a href="#" onclick="document.getElementById('frmpackagedetail').submit();" class="buttonBig p10px20px c5px b large dib">Book Your Tour</a>
						<input type="hidden" name="pkg_slno" value="102645"/>
						</form>
						</p>
											</td>
					</tr>
					</table>
											<div class="mt7px dif">* Mentioned prices may vary depending upon date of travel, hotel availability, surge pricing and seasonal rush.</div>
											<br />
					
					<div class="packageTabs myTabs horizontal mc"><!--MY TABS STARTS-->
					<ul class="fo lsn m0px p0px">
					
											<li id="tab2"><a href="#data2">Itinerary</a></li>
												<li id="tab4"><a href="#data4">Tour Detail</a></li>
												<li id="tab5"><a href="#data5">Rate Card</a></li>
												<li id="tab6"><a href="#data6">Terms &amp; Conditions</a></li>
											</ul>
					
					
											<div class="ic bdr" id="data2"><!--DATA2 START-->
						<br />
						<ul class="lsn m0px p0px">
									<li>
									<p class="b mb5px">Day 1: Arrival Patna Railway station/airport - Half day sightseeing
									</p>
									<div class="data p10px">Pick up at Airport / Railway Station on arrival at Patna. Check into hotel. Sightseeing of the city. Patna was known as<br />
Patliputra in ancient times. It was the capital of powerful kingdom of Magadh which in West started from modern day<br />
Afghanistan and extended till modern day Bangladesh in East. During ancient times,Megasthenes (350-290 BCE), the Greek<br />
historian and traveler, referred to it in Greek as Palibothra or Palimbotra. The place appears in the records of the Chinese<br />
traveller, Fa Hien (5th Century), as Pa-lin-fou. This city has been the main centre of religions like Buddhism, Jainism and<br />
Hinduism in ancient times and is also very important centre for the religion of Sikhism. Visit Patna Museum and explore the<br />
wonderful historical relics and artifacts preserved at the museum. Thereafter visit Kumhrar that has ruins of the ancient city<br />
of Pataliputra. Overnight stay at hotel</div>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 2: Patna - Bodh Gaya - Patna
									</p>
									<div class="data p10px">After breakfast, leave for Bodh Gaya. According to Buddhist traditions, circa 500 BC Prince Gautama Siddhartha, wandering<br />
as an ascetic, reached the banks of the river Phalgu, near the city of Gaya. There he sat in meditation under a bodhi tree<br />
(Ficus religiosa). After three days and three nights of meditation, Siddhartha attained enlightenment and thus became Lord<br />
Buddha. He then spent seven weeks at seven different spots in the vicinity meditating and considering his experience.<br />
The Mahabodhi temple is located in the east adjacent to the original Bodhi tree. It actually stands on the temple erected by<br />
Emperor Ashoka and rises in the form of pyramidal spire till it reaches its neck, which is cylindrical in shape. Several<br />
Buddhist temples and monasteries have been built by the people of Bhutan, China, Japan, Myanmar, Nepal, Sikkim, Sri<br />
Lanka, Taiwan, Thailand, Tibet and Vietnam in a wide area around the Mahabodhi Temple.<br />
In the evening, leave for Patna. Have dinner and night stay in hotel</div>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 3: Patna- Nalanda - Rajgir
									</p>
									<div class="data p10px">After breakfast, leave for Nalanda. This place has the ruins of world famous Nalanda University which thrived between 5th<br />
and 12th century. At its peak, the university attracted scholars and students from as far away as Tibet,China, Greece, and<br />
Persia.[5] Nalanda was ransacked and destroyed by an army under Bakhtiyar Khilji in 1193. Nalanda was one of the world’s<br />
first residential universities. In its heyday, it accommodated over 10,000 students and 2,000 teachers. A vast amount of<br />
what came to comprise Tibetan Buddhism, both its Mahayanaand Vajrayana traditions, stems from the late (9th–12th<br />
century) Nalanda teachers and traditions. Other forms of Buddhism, such as the MahÄyÄna Buddhism followed in<br />
Vietnam,China, Korea and Japan, flourished within the walls of the ancient university.<br />
From Nalanda, travel to Rajgir for overnight stay in the hotel</div>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 4: Rajgir Local sightseeing- Patna airport/railway station.
									</p>
									<div class="data p10px">After breakfast, take a trip of the holy city of Rajgir (Rajgrahi) which is a famous pilgrimage centre for Buddhists and Jains.<br />
Gautam Buddha, the founder of Buddhism came here numerous times with his Sangha. Ceramics dating to about 1000 BC<br />
have been found in the city. There are several archeological sites related to Lord Buddha and Lord Mahavira in this place.<br />
The various hot water springs, which are believed to have curative properties, are sacred to the Buddhists, Hindus, and<br />
Jains. Separate bathing places have been set up for men and women at Saptdharna; the seven streams behind the Saptarni<br />
Caves. Brahmaputra is the hottest spring with water temperature being 45 degree C.<br />
In the evening, leave for Patna airport / railway station.</div>					
									</li>
									<br />					
							</ul>						<!--DATA2 EMD--></div>
											
						<div class="ic bdr" id="data4"><!--DATA4 START-->
						<br />
						Per adult Price - INR 12230 X 2 pax = INR 24460<br />
Validity : Jul to Sep<br />
<br />
HOTEL DETAILS<br />
We select accommodations that reflect the character of the destination. This could mean a handpicked Hotels with Best<br />
of the Wholesale prices<br />
<br />
Hotel New Ajadsatru - RAJGIR<br />
Rajgir is a prominent Buddhist site in India. History, myths and legends still linger in the tourist attractions in Rajgir.<br />
VEHICLE DETAILS<br />
TATA Indigo<br />
Our cars/buses are commercial registered , GPS enabled & Clean new age Cars.Our Vehicles is checked and<br />
replaced on a regular basis with spot checks by our Operations Manager<br />
<br />
No. of Vehicle : 1<br />
No. of Seats :01 PUSHBACK + 02 STRAIGHT BACK<br />
Luggage Space :02 PIECES IN CAR & 02 PIECES ON TOP<br />
<br />
Sightseeing as per the itinerary<br />
03 Breakfast at the hotels mentioned<br />
Accommodation for 3 nights 4 days on double sharing basis<br />
All Transfers, excursions & sightseeing as per the itinerary by private TATA Indigo in Deluxe Package<br />
Below 5 Yrs Child sharing same bed with parents will be Complimentary.<br />
Parking and all transport related expense including Driver Services<br />
All toll taxes, parking fees, Fuel and driver's allowances<br />
Welcome drink on arrival<br />
All Transport & Hotels Related Taxes<br />
GST & all Government Taxes<br />
A 24 - hour helpline.<br />
Assistance on Arrival.<br />
No Hidden CostPersonal expenses such as laundry, telephone calls, tips & gratuity, mineral water, soft & hard drinks, porterage<br />
Anything not mentioned in the inclusions<br />
Additional sightseeing or extra usage of vehicle, other than mentioned in the itinerary<br />
Entrance Fees & Guide charges<br />
Any cost arising due to natural calamities like, landslides, road blockage, political disturbances (strikes), etc (to be borne by the client, who is directly<br />
payable on the spot)<br />
Any increase in Airlines taxes or fuel price at the time of departure, leading to increase in cost on surface transportation & land arrangements, which may<br />
come into effect prior to departure<br />
Still camera/ video camera charger							<p class="b mb5px dif">Inclusions :</p>
							<ul>
																	<li>Hotel</li>
																				<li>Sightseeing</li>
																	</ul>
							<br />
														<p class="b mb5px dif">Exclusions :</p> <ul><li>Personal expenses such as laundry, telephone calls, tips & gratuity, mineral water, soft & hard drinks, porterage</li><li>
Anything not mentioned in the inclusions</li><li>
Additional sightseeing or extra usage of vehicle, other than mentioned in the itinerary</li><li>
Entrance Fees & Guide charges</li><li>
Any cost arising due to natural calamities like, landslides, road blockage, political disturbances (strikes), etc (to be borne by the client, who is directly</li><li>
payable on the spot)</li><li>
Any increase in Airlines taxes or fuel price at the time of departure, leading to increase in cost on surface transportation & land arrangements, which may</li><li>
come into effect prior to departure</li><li>
Still camera/ video camera charger</li></ul><br />
													<!--DATA4 EMD--></div>
							
						<div class="ic bdr" id="data5"><!--DATA5 START-->
						<br />
						
    	<p class="h dif xlarge b mb5px">Hotel Laavish - PATNA</p>
    	<div class="otherDetails aj">Hotel Laavish provides free breakfast and internet access. The hotel in Patna is siuated of 7 km from the<br>
Patna International Airport and 3 km from Golghar.<br>
Distance from Hotel</div><br>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Patna International Airport</td>
				<td class="headHr p5px b">Buddha Smriti Udyaan</td>
				<td class="headHr p5px b">Patna Junction Railway Station</td>
				<td class="headHr p5px b">Uma Cinema Bus Stop</td>
			</tr>
			<tr>
				<td class="data p5px">7</td>
				<td class="data p5px">1</td>
				<td class="data p5px">1</td>
				<td class="data p5px">1</td>
			</tr>
		</table></div><br>						<!--DATA5 EMD--></div>
												<div class="ic bdr" id="data6"><!--DATA6 START-->
						<br />
						~^#^~~^#^~<p><strong>Important Note</strong>

<ul>
	<li>Rates are not valid for Festive peak season.</li>
	<li>Rates are based on Hotels Subject to Availability at the time of making Reservation. In case of unavailability in mentioned hotels,alternate accommodation</li>
	<li>will be arranged in a similar category hotel.</li>
	<li>Rates are subject to change if there is any Fair &amp; Festival, Major conference, events in travel destination</li>
	<li>Early check in / late checks out is subject to availability of rooms.</li>
	<li>Cancellation charges would be as per the company policy.</li>
	<li>Vehicle confirmed will be as per Itinerary and not at disposal. AC will work only in the plains and will be switched off during hill drives.</li>
	<li>All sightseeing mentioned are subject to weather conditions, political conditions &amp; traffic conditions in the destination.</li>
	<li>Any sightseeing missed due to natural calamities / weather conditions is non-refundable.</li>
	<li>All entrances fees will be on direct payment basis as per Itinerary</li>
	<li>It is not advisable to travel in night, if necessary supplement charge applicable</li>
</ul>

<p><strong>Payment Policy</strong>

<ul>
	<li>Deposit of 25% of the package cost at the time of booking.</li>
	<li>Need 50% payment of the package cost, 30 days prior to departure date</li>
	<li>Need 100% payment of the package cost, 15 days prior to departure date</li>
</ul>

<p><strong>Cancellation Policy</strong>

<ul>
	<li>10% of full tour cost - 60 days prior to arrival.</li>
	<li>25% of full tour cost - 30 days prior to arrival.</li>
	<li>50% of full tour cost - between 15 &amp; 29 days prior to tour.</li>
	<li>75% of full tour cost - between 14 &amp; 7 days prior to tour</li>
	<li>100% - within 7 days prior to tour.</li>
</ul>						<!--DATA6 EMD--></div>
											
					<!--MY TABS END--></div>
					";i:1;s:81:"Book Tour Package for Bodhgaya,Rajgir & Nalanda - 3 Nights / 4 Days Tour Packages";i:2;s:134:"book tour package for bodhgaya,rajgir & nalanda - 3 nights / 4 days tour packages, heritage tour packages, patna, rajgir tour packages";i:3;s:184:"Book Tour Package for Bodhgaya,Rajgir & Nalanda - 3 Nights / 4 Days tour packages from Elegant Enterprise - Get attractive 3 Nights / 4 Days Heritage  tour packages for  Patna, Rajgir.";i:4;s:2420:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Patna, Rajgir"        
		                 },
		      "description": "Per adult Price - INR 12230 X 2 pax = INR 24460
Validity : Jul to Sep

HOTEL DETAILS
We select accommodations that reflect the character of the destination. This could mean a handpicked Hotels with Best
of the Wholesale prices

Hotel New Ajadsatru - RAJGIR
Rajgir is a prominent Buddhist site in India. History, myths and legends still linger in the tourist attractions in Rajgir.
VEHICLE DETAILS
TATA Indigo
Our cars/buses are commercial registered , GPS enabled & Clean new age Cars.Our Vehicles is checked and
replaced on a regular basis with spot checks by our Operations Manager

No. of Vehicle : 1
No. of Seats :01 PUSHBACK + 02 STRAIGHT BACK
Luggage Space :02 PIECES IN CAR & 02 PIECES ON TOP

Sightseeing as per the itinerary
03 Breakfast at the hotels mentioned
Accommodation for 3 nights 4 days on double sharing basis
All Transfers, excursions & sightseeing as per the itinerary by private TATA Indigo in Deluxe Package
Below 5 Yrs Child sharing same bed with parents will be Complimentary.
Parking and all transport related expense including Driver Services
All toll taxes, parking fees, Fuel and driver's allowances
Welcome drink on arrival
All Transport & Hotels Related Taxes
GST & all Government Taxes
A 24 - hour helpline.
Assistance on Arrival.
No Hidden CostPersonal expenses such as laundry, telephone calls, tips & gratuity, mineral water, soft & hard drinks, porterage
Anything not mentioned in the inclusions
Additional sightseeing or extra usage of vehicle, other than mentioned in the itinerary
Entrance Fees & Guide charges
Any cost arising due to natural calamities like, landslides, road blockage, political disturbances (strikes), etc (to be borne by the client, who is directly
payable on the spot)
Any increase in Airlines taxes or fuel price at the time of departure, leading to increase in cost on surface transportation & land arrangements, which may
come into effect prior to departure
Still camera/ video camera charger",
		      "name": "Tour Package for Bodhgaya,Rajgir & Nalanda",
		      "telephone": "+91-9400401155"
		    }
		    </script>
			";i:5;N;}