a:4:{i:0;s:3533:"		<div class="h1 p7px pl10px c5px"><h1>No tax benefit on house sale if new flat is in wife's name: ITAT</h1></div>
		<p class="breadcrumb xsmall ar uu p2px5px ffv"><a href="http://www.arihantassociates.in/" class="u color2">Home</a> &rsaquo; <a href="http://www.arihantassociates.in/news.htm" class="u color2">News</a> &rsaquo; No tax benefit on house sale if new flat is in wife's name: ITAT</p><br />
		
		<div class="lh13em" id="newsPage"><!-- news page div starts -->
				
		<div class="news">
		<div class="pr large lh15em ffg b i">
		<div class="p5px">
		
				
		Source: Economic Times, Mumbai<br/><br/>The Income-Tax Appellate Tribunal (ITAT)'s Mumbai bench recently denied a taxpayer I-T benefits available when long-term capital gains arising from sale of a residential property are invested in a new house. <br/><br/>The sole reason for the denial was that the taxpayer bought the new house in his wife and adult daughter's names.<br/><br/>In a similar case, the Delhi HC had taken a view favourable to the taxpayer. ITAT's Mumbai bench, though, was bound by the decision of the Bombay HC, which had taken a contrary view and held that the new property must be owned by the taxpayer or he or she must have legal title over it. <br/><br/>The I-T Act's Section 54 gives two years from the sale date to invest long-term capital gains from the old house in a new house to get tax relief. <br/><br/>"Those taxpayers who are within the jurisdiction of the Bombay High Court must be careful to avoid tax litigation. If the taxpayer wishes to register a new house in the name of his or her spouse and children, it would be wiser to also add his or her own name to it. In such an instance, at least a proportionate deduction (say, one third of the cost of the new house if registered jointly with names of a spouse and a child) would be available to the taxpayer," says Puneet Gupta, Director, People Advisory Services at EY-India.<br/><br/>Under the I-T Act, if a taxpayer makes a profit on sale of a residential house held for at least two years, then such profit is treated as long-term capital gain (LTCG). This gain is taxable at 20% with adjustment for inflation which is referred to as indexation benefit.<br/><br/>If the LTCG component is invested in another house in India within the stipulated period though, then the gain's taxable component is reduced to the extent of this investment, which results in lower tax outgo. <br/><br/>Under I-T Act's Section 54, the period prescribed for investing LTCGs in a new house is two years from the date of the old house's sale. This tax benefit is also available if the taxpayer constructs a new residential house within three years of the old house's sale.<br/><br/>In the case which ITAT recently heard, R Gavankar sold a house which he owned jointly with his wife and did not offer to tax any capital gains. I-T authorities assessed 50% of the LTGC of Rs 17.5 lakh in his hands. His claim for deduction under Section 54 was denied. <br/><br/>Lower tax authorities, including commissioner of I-T (appeals), held that to avail of benefits under this section, the taxpayer must own or have the legal title of the new property.<br/><br/>Gavankar contended before ITAT that Section 54 is a beneficial provision and the I-T benefit should be available to him.</div>
		</div>
		<br class="lh05em" />
		
		<div class="fr ar lh12em">
		<p class="dull i"><b>Posted On : </b>17-Dec-2018</p>	
		</div>
		<p class="cb"></p>
		</div>
		<!-- news page div ends --></div>
		";i:1;s:64:"No tax benefit on house sale if new flat is in wife's name: ITAT";i:2;s:64:"No tax benefit on house sale if new flat is in wife's name: ITAT";i:3;s:64:"No tax benefit on house sale if new flat is in wife's name: ITAT";}