a:6:{i:0;s:17543:"				<div class="h1"><h1>Planet Hollywood Beach Resort Goa 3N Goa</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>Planet Hollywood Beach Resort Goa 3N Goa</p>
				<br />
				
								
						<script language="javascript"> 
							function topDestinationToggle(showHideDiv, switchTextDiv) {
							var ele = document.getElementById(showHideDiv);
							var text = document.getElementById(switchTextDiv);
							if(ele.style.display == "block") {
								ele.style.display = "none";
							  text.innerHTML = "View More &#9660;";
							}
							else {
							  ele.style.display = "block";
							  text.innerHTML = "View Less &#9650;";
							}
							}
		                </script>
											<script type="text/javascript">			
					(function($){	
					  $(function(){
						$('[id^=detailslider]').each(function(){
							$(this).DG_Slider({
								auto: true, mode:'fade', pager:true, pagerType:'short',controls:true
							});
						})
				
						$('a[rel=gall]').fancybox()
					  });	
					}(jQuery))
					</script>
					
					<br />
					<div class="data">
					<table class="w100 formTable bdr0 imgWidth">
					<tr>
					<td class="p10px">
					<table class="w100 packageForm">
											<tr>
						<td class="b p5px w125px vat">Duration </td>
						<td class="p5px pl0px vat">
						3 Nights / 4 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Goa City</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 15550 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="Planet Hollywood Beach Resort Goa 3N Goa - 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="82542"/>
						</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/146335.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/146335.jpg"  width="150" height="150"    alt="Planet Hollywood Beach Resort Goa" title="Planet Hollywood Beach Resort Goa" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					GOA<br />
Often referred to as the Pearl of the Orient, the city is famous for its lovely beaches and is a perfect place for honeymooners and water sport enthusiasts.<br />
Holiday Highlight<br />
The first Planet Hollywood holiday resort to open outside the U.S.<br />
Best Time to Visit<br />
If you been to any top beach resort or most popular hotel in Goa you will agree that its always about the stay experience during your holidays that you take away with you when you pack bags and return home. We at Planet Hollywood beach resort as one the most famous and elite beach resort in Goa know that the stay experience is the most important of all when it comes to holiday or vacation with family.<br />
Preferred months : January, February, March, April, September, October, November, December<br />
Description<br />
Planet Hollywood being one of the best and popular beach resort in Goa treats everyone with Royalty and gives them many reasons to remember their stay. It is Indias first ever adaptation of Hollywood Planet beach resort in Los Angeles it has class par excellence and truly represent taste of LA. Right from the lobby to gardens and swimming pools you feel amazed by its true beauty. The interior wont let you take eyes off and you feel surreal in the atmosphere. The pool side tents are exclusively for those who enjoy the company of solitude and nature. The Maharani Suite stands to its name and makes you feel like royal!!<br />
Luxury Inclusions<br />
Scheduled Airport / Madgaon Railway station transfers by AC coach<br />
Accommodation in Superior Garden View<br />
Welcome drinks (non-alcoholic drink) on arrival<br />
In room Leg Massager<br />
Sound bar with a dock for personal music device<br />
Complimentary access of wi fi in the resort<br />
Buffet / fixed menu breakfast, lunch and dinner in standard buffet venues<br />
Complimentary use of Tea/Coffee maker in all the rooms, replenished daily<br />
Complimentary 02 bottles of packaged drinking water, replenished daily<br />
Complimentary use of swimming pool and Trance Gym<br />
Safety deposit boxes and hair dryers in all rooms<br />
20% discount at Pink Room Spa<br />
For complimentary night Optional meal supplement @ INR 2500/- per adult & Rs.1250/- per child (6-12 yrs) for all three buffet meals<br />
2 Kids under 12 Complimentary with existing bedding. Extra bed charged will be INR 900 inclusive of taxes per night.<br />
Currently, applicable taxes. Any change in tax structure, would affect the rates accordingly<br />
Inclusion from April Onwards<br />
Daily local newspaper<br />
In room Leg Massager<br />
Complimentary car parking<br />
Complimentary Wifi access<br />
Welcome drinks (non-alcoholic drink) on arrival<br />
Included Breakfast, lunch and dinner<br />
Complimentary use of Tea/Coffee maker in all the rooms, replenished daily<br />
Complimentary use of all leisure facilities including gymnasium, swimming pool, childrens wading pool , e.t.c<br />
The above mentioned room rates are inclusive of all presently applicable taxes, however any subsequent government levies will be charged additionally.<br />
Transfers : Complimentary pick / drop - Goa international airport , Margao railway station & Margao KTC bus station are included for bookings only with APAI meal planAny Air or train fare. Monument fee / Camera fee.<br />
Kind of Personal Expenses or Optional Tours/Meals other than specified.<br />
Cost does not include any other thing apart from the inclusions.<br />
Medical Travel insurance.<br />
Surcharges applicable during Festival, Peak Season & Special Events.<br />
Any changes in the taxes levied by Govt.<br />
Rate supplements for the following peak period, both dates inclusive.Independence Day & Rakhi Long Weekend 13th August 2016 18th August 2016 - Superior Garden View @ INR 1500 per room per nigh / Luxury Pool View @ INR 2500 per room per night<br />
Ganesh Chaturthi : 03rd September 05th September 2016 - Superior Garden View @ INR 1500 per room per nigh / Luxury Pool View @ INR 2500 per room per night<br />
Dussehra festival: 07th October 11th October 2016- Superior Garden View @ INR 1500 per room per night / Luxury Pool View @ INR 2500 per room per night01-0931-03<br />							<div class="headHr">
				            <p class="p7px b pl10px xlarge">Hotel Detail : </p>
				            </div>
															<div class="data lh13em p20px aj mb7px">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px"><p class="fr lh0">
								
																	<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_on.png" alt=""/>
																		<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_on.png" alt=""/>
																		<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_on.png" alt=""/>
																		<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_on.png" alt=""/>
																		<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_on.png" alt=""/>
																		<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_off.png" alt=""/>
																		<img class="vam" src="https://static.tourtravelworld.com/images/star_ratings_off.png" alt=""/>
																	
								</p>
								<div class="mb5px">
								<h2 class="dif b xxlarge">Planet Hollywood Beach Resort Goa</h2>
								</div>
								<p class="cb"></p>
								<p><b>Address :</b> Goa City, Goa, India</p>
								<p><b>Facility :</b> </p>
								<div class="mt7px">Holiday Highlight
The first Planet Hollywood holiday resort to open outside the U.S.

Best Time to Visit
If you been to any top beach resort or most popular hotel in Goa you will agree that its always about the stay experience during your holidays that you take away with you when you pack bags and return home. We at Planet Hollywood beach resort as one the most famous and elite beach resort in Goa know that the stay experience is the most important of all when it comes to holiday or vacation with family.
Preferred months : January, February, March, April, September, October, November, December
Description
Planet Hollywood being one of the best and popular beach resort in Goa treats everyone with Royalty and gives them many reasons to remember their stay. It is Indias first ever adaptation of Hollywood Planet beach resort in Los Angeles it has class par excellence and truly represent taste of LA. Right from the lobby to gardens and swimming pools you feel amazed by its true beauty. The interior wont let you take eyes off and you feel surreal in the atmosphere. The pool side tents are exclusively for those who enjoy the company of solitude and nature. The Maharani Suite stands to its name and makes you feel like royal!!</div>
								</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="showZoomImage2" href="https://ttw.wlimg.com/hotel-package-images/photo-big/dir_9/257644/16116.jpg"><img src="https://ttw.wlimg.com/hotel-package-images/photo-small/dir_9/257644/16116.jpg"  width="150" height="150"    alt="Planet Hollywood Beach Resort Goa" title="Planet Hollywood Beach Resort Goa" class="bdr"  /></a></p></div></li>
																					</ul>
									</div>
									</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>Stay Included</li>
															</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Any Air or train fare. Monument fee / Camera fee.</li><li>
Kind of Personal Expenses or Optional Tours/Meals other than specified.</li><li>
Cost does not include any other thing apart from the inclusions.</li><li>
Medical Travel insurance.</li><li>
Surcharges applicable during Festival, Peak Season & Special Events.</li><li>
Any changes in the taxes levied by Govt.</li><li>
Rate supplements for the following peak period, both dates inclusive.Independence Day & Rakhi Long Weekend 13th August 2016 18th August 2016 - Superior Garden View @ INR 1500 per room per nigh / Luxury Pool View @ INR 2500 per room per night</li><li>
Ganesh Chaturthi : 03rd September 05th September 2016 - Superior Garden View @ INR 1500 per room per nigh / Luxury Pool View @ INR 2500 per room per night</li><li>
Dussehra festival: 07th October 11th October 2016- Superior Garden View @ INR 1500 per room per night / Luxury Pool View @ INR 2500 per room per night</li></ul><br />
											
						<p class="large b mb5px dif">Terms &amp; Conditions :</p>~^#^~~^#^~<div class="hld_tbhead" style="margin: 0px; padding: 0px 0px 5px; color: rgb(46, 103, 172); font-family: Arial, Helvetica, Tahoma, sans-serif; font-size: 15px; font-weight: bold; box-sizing: border-box;">Terms &amp; Conditions</div>

<ul>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">Price mentioned is on per person basis.</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">Bookings are applicable only on twin sharing basis.</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">Weekend supplement (Friday/Saturday) : INR 700/- per night Inclusive of all taxes</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">Luxury Pool View Supplement : INR 1200/- per night Inclusive of all taxes</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">Extra adult in the same room will be charged 35% of double room cost</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">1.40% Service taxes extra.</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">Standard Check-in timing is 1400 hrs and our check-out time is 1200 hrs</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">Bookings are subject to availability with the hotel.</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">Package rates are subject to change without any prior notice.</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">Child below 05 Yrs complimentary.</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">The above package rate is not valid during national holidays, festivals, long weekends, Christmas and New Year.</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">Goibibo.com will provide alternate or similar category of hotel in case the hotel mentioned in program is not available.</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">All cancellations &amp; amendments will be done as per hotel policy.</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">The package cannot be combined with any other offer.</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">The guest must carry photo identification like Passport/Driving License/Voter ID Card IN ORIGINAL at the point of check in at the hotel.</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">Grandindiatrip.com reserves the right to change/modify or terminate the offer any time at its own discretion and without any prior notice.</li>
	<li style="margin: 0px 0px 0px 15px; padding: 0px 0px 5px; list-style-image: none; box-sizing: border-box;">A Surcharge may be levied by the hotel during National Holidays/Festive period/Extended Weekends, New year etc.</li>
</ul>


We reserves the right to change/modify or terminate the offer any time at its own discretion and without any prior notice. A Surcharge may be levied by the hotel during National Holidays/Festive period/Extended Weekends, New year etc.<br />
We reserves the right to change/modify or terminate the offer any time at its own discretion and without any prior notice. A Surcharge may be levied by the hotel during National Holidays/Festive period/Extended Weekends, New year etc.						
    	<p class="h dif xlarge b mb5px">Planet Hollywood Beach Resort Goa 3N Goa</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Price Details</td>
				<td class="headHr p5px b">Base Price</td>
			</tr>
			<tr>
				<td class="data p5px">Single Occupancy</td>
				<td class="data p5px">Rs. 29773</td>
			</tr>
			<tr>
				<td class="data p5px">Twin Sharing</td>
				<td class="data p5px">Rs. 15550</td>
			</tr>
		</table></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="Planet Hollywood Beach Resort Goa 3N Goa - 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="82542"/>
						</form>
						</div>
						
						";i:1;s:79:"Book Planet Hollywood Beach Resort Goa 3N Goa - 3 Nights / 4 Days Tour Packages";i:2;s:127:"book planet hollywood beach resort goa 3n goa - 3 nights / 4 days tour packages, heritage tour packages, goa city tour packages";i:3;s:186:"Book Planet Hollywood Beach Resort Goa 3N Goa - 3 Nights / 4 Days tour packages from Grand India Tours & Travels - Get attractive 3 Nights / 4 Days Heritage  tour packages for  Goa City.";i:4;s:4425:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Goa City"        
		                 },
		      "description": "GOA
Often referred to as the Pearl of the Orient, the city is famous for its lovely beaches and is a perfect place for honeymooners and water sport enthusiasts.
Holiday Highlight
The first Planet Hollywood holiday resort to open outside the U.S.
Best Time to Visit
If you been to any top beach resort or most popular hotel in Goa you will agree that its always about the stay experience during your holidays that you take away with you when you pack bags and return home. We at Planet Hollywood beach resort as one the most famous and elite beach resort in Goa know that the stay experience is the most important of all when it comes to holiday or vacation with family.
Preferred months : January, February, March, April, September, October, November, December
Description
Planet Hollywood being one of the best and popular beach resort in Goa treats everyone with Royalty and gives them many reasons to remember their stay. It is Indias first ever adaptation of Hollywood Planet beach resort in Los Angeles it has class par excellence and truly represent taste of LA. Right from the lobby to gardens and swimming pools you feel amazed by its true beauty. The interior wont let you take eyes off and you feel surreal in the atmosphere. The pool side tents are exclusively for those who enjoy the company of solitude and nature. The Maharani Suite stands to its name and makes you feel like royal!!
Luxury Inclusions
Scheduled Airport / Madgaon Railway station transfers by AC coach
Accommodation in Superior Garden View
Welcome drinks (non-alcoholic drink) on arrival
In room Leg Massager
Sound bar with a dock for personal music device
Complimentary access of wi fi in the resort
Buffet / fixed menu breakfast, lunch and dinner in standard buffet venues
Complimentary use of Tea/Coffee maker in all the rooms, replenished daily
Complimentary 02 bottles of packaged drinking water, replenished daily
Complimentary use of swimming pool and Trance Gym
Safety deposit boxes and hair dryers in all rooms
20% discount at Pink Room Spa
For complimentary night Optional meal supplement @ INR 2500/- per adult & Rs.1250/- per child (6-12 yrs) for all three buffet meals
2 Kids under 12 Complimentary with existing bedding. Extra bed charged will be INR 900 inclusive of taxes per night.
Currently, applicable taxes. Any change in tax structure, would affect the rates accordingly
Inclusion from April Onwards
Daily local newspaper
In room Leg Massager
Complimentary car parking
Complimentary Wifi access
Welcome drinks (non-alcoholic drink) on arrival
Included Breakfast, lunch and dinner
Complimentary use of Tea/Coffee maker in all the rooms, replenished daily
Complimentary use of all leisure facilities including gymnasium, swimming pool, childrens wading pool , e.t.c
The above mentioned room rates are inclusive of all presently applicable taxes, however any subsequent government levies will be charged additionally.
Transfers : Complimentary pick / drop - Goa international airport , Margao railway station & Margao KTC bus station are included for bookings only with APAI meal planAny Air or train fare. Monument fee / Camera fee.
Kind of Personal Expenses or Optional Tours/Meals other than specified.
Cost does not include any other thing apart from the inclusions.
Medical Travel insurance.
Surcharges applicable during Festival, Peak Season & Special Events.
Any changes in the taxes levied by Govt.
Rate supplements for the following peak period, both dates inclusive.Independence Day & Rakhi Long Weekend 13th August 2016 18th August 2016 - Superior Garden View @ INR 1500 per room per nigh / Luxury Pool View @ INR 2500 per room per night
Ganesh Chaturthi : 03rd September 05th September 2016 - Superior Garden View @ INR 1500 per room per nigh / Luxury Pool View @ INR 2500 per room per night
Dussehra festival: 07th October 11th October 2016- Superior Garden View @ INR 1500 per room per night / Luxury Pool View @ INR 2500 per room per night01-0931-03",
		      "name": "Planet Hollywood Beach Resort Goa 3N Goa",
		      "telephone": "+91-9415285186"
		    }
		    </script>
			";i:5;N;}