Die Merkblätter werden beim Klicken auf den untenstehenden Button von externen Quellen unserer Partner bereitgestellt.
Bitte beachten Sie die Datenschutzerklärung.
<!--MMB-Start-->

<script>function FensterOeffnen (Adresse, breite, hoehe) {MeinFenster = window.open(Adresse, "Zweitfenster", "width="+breite+",height="+hoehe+",left=200,top=200,scrollbars=1");MeinFenster.focus();}</script><script>function toggleDiv(element){ if(document.getElementById(element).style.display == 'none') {document.getElementById(element).style.display = 'block';} else document.getElementById(element).style.display = 'none';}</script>

<script language="JavaScript" type="text/javascript" nonce="2726c7f26c">
function toggleDiv(element){
if(document.getElementById(element).style.display == 'none') {
	document.getElementById(element).style.display = 'block';
} else {
	document.getElementById(element).style.display = 'none';
}
}
function toggleRubrikDiv(element, id, iconset){

	if(document.getElementById(element).style.display == 'none') {
		document.getElementById(element).style.display = 'block';
		if (iconset > 0) { //neue Fassung
			document.getElementById('mehr_rubrik_'+id).style.display = 'none';
			document.getElementById('mehr_'+id).style.display = 'block';
		}		
	}
	 else 
		document.getElementById(element).style.display = 'none';
}
function toggleDoubleDiv(element1,element2){
if(document.getElementById(element1).style.display == 'none') {
	document.getElementById(element1).style.display = 'block';
	document.getElementById(element2).style.display = 'none';
} else {
	document.getElementById(element1).style.display = 'none';
	document.getElementById(element2).style.display = 'block';
}
}

function showResult(suchstr, kd_nr, header) {
	document.getElementById("mmb_liste").style.display = 'none';
	xmlhttp = new XMLHttpRequest();
	xmlhttp.onreadystatechange = function() {
		if (xmlhttp.readyState == 4 && xmlhttp.status == 200) {
			document.getElementById("txtHint").innerHTML = xmlhttp.responseText;
		}
	}
	xmlhttp.open("GET","https://www.deubner-online.de/einbau/mmo/merkblattpages/hintergrundladen.php?s="+suchstr+"&kd_nr="+kd_nr+"&header="+header);
	xmlhttp.send();
}

function searchReset() {
	document.getElementById("suchbegriff").value='';
	document.getElementById("mmb_liste").style.display = 'block';
	document.getElementById("txtHint").innerHTML = '';
}
	
document.onkeydown = function(event) {
	if (event.keyCode == 13) { //Eingabetaste
		event.preventDefault() //Löschen des Events
		showResult(document.getElementById('suchbegriff').value, '001b000000sUyU4', '');
	}
}


</script>

<!--001b000000sUyU4|OTA-2023183925--><style type="text/css">
	
.dummy{
001b000000sUyU4_OTA-2023183925;
}
.rubrik_header {
width:100%;
height:40px;
background-color:#f1f1f1;
margin-top:30px;
margin-bottom:10px;
}

.rubrikbild_hg {
width:40px;
height:40px;
background-color:#ddd;
float:left;
}

.deubner-mmb .rubrik {
padding-left:10px;
padding-top:10px;
height:40px;
vertical-align:middle;
float:left;
}

h5 {
display:inline;
}

li.mehr {
margin-top:10px;
margin-bottom:5px;
list-style:none;
}

img.download {
width:12px;
}

.deubner-merkblaetter {
hyphens: auto;
}

.iexpl {
display:none;
font-size:11px;
color:red;
}

.deubner-merkblaetter hr {
border: none;
border-top: 1px solid #aaaaaa;
height: 1px;
color:transparent;
}

.datenschutz {
margin-top:20px;
font-size:10px;
}

form#eingabe_suchbegriff{
margin-bottom:20px;
}

img#lupe, img#lupe_alle, img.download {
display:inline;
}

input#suchbegriff {
width:300px;
display:inline;
}

#txtHint {
margin-top:40px;
}

@media screen and (max-width: 400px) {
input#suchbegriff {
display:block;
width:100%;
}
}

.dummy{
001b000000sUyU4_OTA-2023183925_;
}
</style>
<div class="deubner-merkblaetter deubner-mmb">
<a id="ergebnisliste"></a><div class="einleitungstext" style="margin-bottom:30px;"><p>Unsere Mandanten-Merkblätter und Checklisten zeigen Ihnen den Weg durch den deutschen Steuerdschungel. Mit vielen Berechnungsbeispielen und Steuertipps beantworten die Merkblätter die wichtigsten Fragen rund ums Steuerrecht. Bitte nehmen Sie Kontakt mit uns auf, wenn Sie weiter gehende Fragen haben. Wir beraten Sie gerne!</p></div>
<div id="suchsteuerung">
	<form id="eingabe_suchbegriff">
		<input type="text" id="suchbegriff" placeholder="Suche Merkblätter">&nbsp;&nbsp;
		<a href="javascript:void(0);" onclick="showResult(document.getElementById('suchbegriff').value, '001b000000sUyU4', '');"><img id="lupe" alt="lupe" src="https://www.deubner-online.de/einbau/mio/bin/img/Lupe.png"></a>&nbsp;&nbsp;<a href="javascript:void(0);" onclick="searchReset();"><img id="lupe_alle" alt="lupe_alle" src="https://www.deubner-online.de/einbau/mio/bin/img/Lupe_alle.png"></a>
	</form>
</div><div id="mmb_liste"><div class="rubrik_container"><div class = "rubrik_header" id="rubrik_header1"><div id="hg_1" class="rubrikbild_hg"><img class="rubrikbild" id="icon_1" src="https://www.deubner-online.de/einbau/mmo/merkblattpages/images/icon_alle_stz1.png"></div><div class="rubrik"><a href="javascript:toggleRubrikDiv('rubrik_1', 1, 1);"><h5 class="rubrik_n">Alle Steuerzahler</h5></a></div></div>
						<div id="rubrik_1" style="display:block;" ><ul><li class="merkblattzeile"><a class="anker" name="merkblatt301"></a><a class="merkblatt" href="javascript:toggleDiv('mb_301');">Influencer und Steuern&nbsp;&nbsp;<span class="update">[Update]</span></a><div id="mb_301" class="mb_teaser" style="display:none;"><p class="mb_teaser">Auch Influencer und Content Creator m&uuml;ssen sich mit steuerlichen Pflichten auseinandersetzen - von der Einkommen-, Gewerbe- und Umsatzsteuer bis hin zu Fragen der Steuererkl&auml;rung. Das Merkblatt erl&auml;utert Ihnen, welche Einnahmen steuerpflichtig sind, welche Besonderheiten bei Sachzuwendungen gelten und was beim Wegzug ins Ausland beachtet werden muss.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=influencer_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt213"></a><a class="merkblatt" href="javascript:toggleDiv('mb_213');">Steuerberaterkosten</a><div id="mb_213" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die Geb&uuml;hrenberechnung von Steuerberatern ist in der Steuerberaterverg&uuml;tungsverordnung (StBVV) festgelegt. In diesem Merkblatt erfahren Sie anhand von vielen Beispielen, wie die Betr&auml;ge der von uns ausgestellten Rechnung zustande kommen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=steuerberaterkosten_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt3"></a><a class="merkblatt" href="javascript:toggleDiv('mb_3');">Beratungscheck</a><div id="mb_3" class="mb_teaser" style="display:none;"><p class="mb_teaser">Besch&auml;ftigen Sie eine Haushaltshilfe? Haben Sie sich beruflich fortgebildet? All dies kann steuerlich relevant sein! Mit dieser Checkliste k&ouml;nnen Sie schon vor unserem Beratungsgespr&auml;ch Ihren individuellen Beratungsbedarf einsch&auml;tzen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=beratungscheck_stb_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt276"></a><a class="merkblatt" href="javascript:toggleDiv('mb_276');">Abgrenzung von Herstellungs- und Erhaltungskosten</a><div id="mb_276" class="mb_teaser" style="display:none;"><p class="mb_teaser">Anschaffungs- oder Herstellungskosten werden grunds&auml;tzlich &uuml;ber die Nutzungsdauer des Wirtschaftsguts abgeschrieben, w&auml;hrend Erhaltungsaufwendungen bereits im Jahr ihrer Entstehung steuerlich voll abzugsf&auml;hig sind. Dieses Merkblatt erkl&auml;rt Ihnen, wie Sie den Begriff der Anschaffungs- bzw. Herstellungskosten von dem der Erhaltungsaufwendungen abgrenzen k&ouml;nnen, und worauf Sie dabei achten m&uuml;ssen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=herstellungskosten_erhaltungsaufwand_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt214"></a><a class="merkblatt" href="javascript:toggleDiv('mb_214');">Au&szlig;ergew&ouml;hnliche Belastungen</a><div id="mb_214" class="mb_teaser" style="display:none;"><p class="mb_teaser">Aufwendungen, die zwangsl&auml;ufig und au&szlig;ergew&ouml;hnlich sind (z.B. Krankheitskosten), k&ouml;nnen steuerlich als au&szlig;ergew&ouml;hnliche Belastungen anerkannt werden. Welche Kosten in welcher H&ouml;he ansetzbar sind, erfahren Sie hier.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=aussergewoehnliche_belastungen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt201"></a><a class="merkblatt" href="javascript:toggleDiv('mb_201');">Belege f&uuml;r die Einkommensteuerberatung 2024</a><div id="mb_201" class="mb_teaser" style="display:none;"><p class="mb_teaser">Ihre Einkommensteuererkl&auml;rung steht an? Bereiten Sie sich auf unseren n&auml;chsten Termin vor, indem Sie mit dieser Checkliste bereits alle n&ouml;tigen Unterlagen zusammentragen. <br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=belege_einkommensteuerberatung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt291"></a><a class="merkblatt" href="javascript:toggleDiv('mb_291');">Berliner Testament</a><div id="mb_291" class="mb_teaser" style="display:none;"><p class="mb_teaser">Bei einem Berliner Testament errichten die Ehepartner ein gemeinschaftliches Testament, setzen sich gegenseitig als Erben ein und bestimmen, dass nach dem Tod des Zweitversterbenden der Nachlass an die Kinder &uuml;bergehen soll. In diesem Merkblatt erfahren Sie alles, was Sie zu Errichtung eines Berliner Testaments sowie zur Vor- und Nacherbschaft wissen sollten - mit vielen Praxisbeispielen!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=berliner_testament_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt9"></a><a class="merkblatt" href="javascript:toggleDiv('mb_9');">Besteuerung der Rentner und Pension&auml;re</a><div id="mb_9" class="mb_teaser" style="display:none;"><p class="mb_teaser">Seit 2005 sind auch Renteneink&uuml;nfte teilweise steuerpflichtig. Weil ihre Rente den Grundfreibetrag &uuml;bersteigt, m&uuml;ssen seitdem immer mehr Rentner eine Einkommensteuererkl&auml;rung abgeben. Das Merkblatt erkl&auml;rt die komplizierte Berechnung und sch&uuml;tzt Sie vor hohen Steuernachforderungen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=besteuerung_rentner_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt197"></a><a class="merkblatt" href="javascript:toggleDiv('mb_197');">Besteuerungsverfahren</a><div id="mb_197" class="mb_teaser" style="display:none;"><p class="mb_teaser">Der Weg von der Steuererkl&auml;rung &uuml;ber ein m&ouml;gliches Einspruchs- und Gerichtsverfahren hin zur Steuerfestsetzung und -erhebung: Hier finden Sie den Fahrplan und alle Aspekte, die Sie in den einzelnen Phasen beachten sollten.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=besteuerungsverfahren_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt104"></a><a class="merkblatt" href="javascript:toggleDiv('mb_104');">Eingetragene Lebenspartner</a><div id="mb_104" class="mb_teaser" style="display:none;"><p class="mb_teaser">Gleichgeschlechtliche Partnerschaften sind inzwischen zwar in der Mitte der Gesellschaft angekommen, aber es existieren immer noch steuerliche Besonderheiten. Hier finden Sie alle wichtigen Informationen f&uuml;r Ihre steuerlichen Fragen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=eingetragene_lebenspartner_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt4"></a><a class="merkblatt" href="javascript:toggleDiv('mb_4');">Elektronische &Uuml;bermittlung von Steuererkl&auml;rungen</a><div id="mb_4" class="mb_teaser" style="display:none;"><p class="mb_teaser">Unternehmer sind schon seit Jahren verpflichtet, das ELSTER-Verfahren zu nutzen. Auch bei privaten Steuererkl&auml;rungen setzt sich das Verfahren mehr und mehr durch. Das Merkblatt lotst Sie durch den komplizierten Registrierungsprozess und erl&auml;utert alle Regelungen, die Sie beachten m&uuml;ssen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=elektr_uebermittlung_steuererklaerungen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt292"></a><a class="merkblatt" href="javascript:toggleDiv('mb_292');">Erbfolge und Testament</a><div id="mb_292" class="mb_teaser" style="display:none;"><p class="mb_teaser">Wie sieht die gesetzliche Erbfolge aus? Welche Vorgaben sind bei der Errichtung eines Testaments einzuhalten? Was ist ein Verm&auml;chtnis? Wann f&auml;llt Erbschaftsteuer an? Was ist der Pflichtteil und wer hat Anspruch darauf? Antworten auf diese und viele weitere Fragen finden Sie in diesem Merkblatt - mit vielen Praxisbeispielen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=erbfolge_testament_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt273"></a><a class="merkblatt" href="javascript:toggleDiv('mb_273');">Erbschaftsteuer</a><div id="mb_273" class="mb_teaser" style="display:none;"><p class="mb_teaser">Verschonungsregelungen, Steuerklassen, Freibetr&auml;ge: Das deutsche Erbschaft- und Schenkungsteuerrecht ist kompliziert. Mit diesem Merkblatt behalten Sie den &Uuml;berblick und erfahren, welche Gestaltungsm&ouml;glichkeiten sie haben, um das steuerliche Optimum herauszuholen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=erbschaftsteuer_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt6"></a><a class="merkblatt" href="javascript:toggleDiv('mb_6');">Familienf&ouml;rderung</a><div id="mb_6" class="mb_teaser" style="display:none;"><p class="mb_teaser">Familien mit Kindern werden in Deutschland auf vielen Ebenen unterst&uuml;tzt: Dazu geh&ouml;ren unter anderem Kindergeld, Freibetr&auml;ge, Elterngeld oder der steuerliche Abzug von Betreuungskosten. In diesem Merkblatt erhalten Sie die n&ouml;tigen Informationen, um diese Vorteile effektiv zu nutzen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=familienfoerderung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt7"></a><a class="merkblatt" href="javascript:toggleDiv('mb_7');">Gesundheitskosten</a><div id="mb_7" class="mb_teaser" style="display:none;"><p class="mb_teaser">"Gesetzlich oder privat?" Im Steuerrecht k&ouml;nnen Sie viele Ausgaben f&uuml;r Ihre Gesundheit ganz oder teilweise auf Ihre Lohn- und Einkommensteuer anrechnen. Das Merkblatt erkl&auml;rt, wie Sie Ihre Gesundheitsausgaben in der Steuererkl&auml;rung optimal ansetzen k&ouml;nnen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=gesundheitskosten_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt8"></a><a class="merkblatt" href="javascript:toggleDiv('mb_8');">Haushaltsnahe Dienstleistungen</a><div id="mb_8" class="mb_teaser" style="display:none;"><p class="mb_teaser">Der Fiskus f&ouml;rdert haushaltsnahe Dienstleistungen und Handwerkerleistungen mit einem Steuerbonus. Das Merkblatt zeigt Ihnen &uuml;bersichtlich die M&ouml;glichkeiten, aber auch die Grenzen dieser Beg&uuml;nstigung auf.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=haushaltsnahe_dienstleistungen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt282"></a><a class="merkblatt" href="javascript:toggleDiv('mb_282');">Heizungsgesetz - GEG-Novelle</a><div id="mb_282" class="mb_teaser" style="display:none;"><p class="mb_teaser">Nach einer turbulenten Debatte hat das Heizungsgesetz endlich den Bundesrat passiert und tritt zum 01.01.2024 in Kraft. Insbesondere die Hauseigent&uuml;mer unter Ihren Mandanten erfahren in diesem Merkblatt, wie die neuen Regelungen aussehen und welcher Handlungsbedarf f&uuml;r Immobilieneigent&uuml;mer besteht.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=heizungsgesetz_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt270"></a><a class="merkblatt" href="javascript:toggleDiv('mb_270');">Inflationsausgleichspr&auml;mie</a><div id="mb_270" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die Inflationsausgleichspr&auml;mie erm&ouml;glicht Arbeitgebern, eine steuer- und sozialversicherungsfreie Zahlung an Arbeitnehmer in H&ouml;he von maximal 3.000 &#128; zu leisten. In diesem Merkblatt erfahren Sie, welche Voraussetzungen f&uuml;r die steuerfreie Zahlung der Pr&auml;mie vorliegen m&uuml;ssen und welche Besonderheiten zu beachten sind.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=inflationsausgleichspraemie_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt277"></a><a class="merkblatt" href="javascript:toggleDiv('mb_277');">Jobticket und Deutschlandticket: Steuerliche Aspekte</a><div id="mb_277" class="mb_teaser" style="display:none;"><p class="mb_teaser">Mit einem Jobticket und dem neu eingef&uuml;hrten Deutschlandticket k&ouml;nnen Arbeitgeber und Arbeitnehmer sparen. In diesem Merkblatt erfahren Sie alles, was Sie &uuml;ber die steuer- und sozialversicherungsfreie Nutzung eines Jobtickets wissen m&uuml;ssen!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=jobticket_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt288"></a><a class="merkblatt" href="javascript:toggleDiv('mb_288');">Korrekturverfahren</a><div id="mb_288" class="mb_teaser" style="display:none;"><p class="mb_teaser">In der Praxis kommt es h&auml;ufig vor, dass ein erlassener Steuerbescheid fehlerhaft ist. Hier sieht die Abgabenordnung verschiedene M&ouml;glichkeiten vor, eine &Auml;nderung herbeizuf&uuml;hren. Dieses Merkblatt erl&auml;utert Ihnen, wie diese M&ouml;glichkeiten aussehen und was es hierbei zu beachten gibt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=korrekturverfahren_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt260"></a><a class="merkblatt" href="javascript:toggleDiv('mb_260');">Kryptow&auml;hrungen</a><div id="mb_260" class="mb_teaser" style="display:none;"><p class="mb_teaser">Kryptow&auml;hrungen, wie z.B. Bitcoin, haben mittlerweile schon eine &uuml;ber zehnj&auml;hrige Historie von Aufschwung und Abschwung hinter sich. Doch was sind Kryptow&auml;hrungen &uuml;berhaupt und wie k&ouml;nnen sie in Deutschland steuerlich eingeordnet werden? Dieses Merkblatt gibt Ihnen Antworten!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=kryptowaehrungen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt272"></a><a class="merkblatt" href="javascript:toggleDiv('mb_272');">Meldepflicht f&uuml;r Betreiber elektronischer Marktpl&auml;tze</a><div id="mb_272" class="mb_teaser" style="display:none;"><p class="mb_teaser">Zur Umsetzung der Richtlinie "DAC 7" wurde das Plattformen-Steuertransparenzgesetz (PStTG) beschlossen. Dieses Gesetz sieht steuerliche Meldepflichten für die Betreiber von digitalen Plattformen vor. Auch für Verkäufer auf diesen Plattformen können sich gegebenenfalls steuerliche Folgen ergeben. Mit diesem Merkblatt können Sie sich umfassend zum PStTG informieren!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=meldepflicht_plattformbetreiber_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt228"></a><a class="merkblatt" href="javascript:toggleDiv('mb_228');">Private Ver&auml;u&szlig;erungsgesch&auml;fte</a><div id="mb_228" class="mb_teaser" style="display:none;"><p class="mb_teaser">Man muss kein Unternehmer sein, damit das Finanzamt bei Verk&auml;ufen Steuern von einem einfordern kann. Daf&uuml;r gibt es das Konstrukt "private Ver&auml;u&szlig;erungsgesch&auml;fte". Welche Verk&auml;ufe hierunter fallen und was dann bez&uuml;glich der Steuer zu beachten bzw. empfehlen ist, das wird in diesem Merkblatt erkl&auml;rt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=private_veraeusserungsgeschaefte_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt107"></a><a class="merkblatt" href="javascript:toggleDiv('mb_107');">Scheidung</a><div id="mb_107" class="mb_teaser" style="display:none;"><p class="mb_teaser">Gehen Ehepartner getrennte Wege, sind nicht nur der Unterhalt und das Sorgerecht f&uuml;r die Kinder zu regeln, sondern auch die steuerlichen Konsequenzen einer Scheidung zu bedenken. Das Merkblatt erkl&auml;rt die steuerlichen Gestaltungsm&ouml;glichkeiten, z.B. wie Sie den Zugewinnausgleich optimal gestalten oder Unterhaltsleistungen ansetzen k&ouml;nnen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=scheidung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt274"></a><a class="merkblatt" href="javascript:toggleDiv('mb_274');">Schenkungsteuer</a><div id="mb_274" class="mb_teaser" style="display:none;"><p class="mb_teaser">Verschonungsregelungen, Steuerklassen, Freibetr&auml;ge: Das deutsche Erbschaft- und Schenkungsteuerrecht ist kompliziert. Mit diesem Merkblatt behalten Sie den &Uuml;berblick und erfahren, welche Gestaltungsm&ouml;glichkeiten Sie haben, um das steuerliche Optimum herauszuholen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=schenkungsteuer_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt13"></a><a class="merkblatt" href="javascript:toggleDiv('mb_13');">Sonderausgaben</a><div id="mb_13" class="mb_teaser" style="display:none;"><p class="mb_teaser">Neben den Werbungskosten stellen die Sonderausgaben einen weiteren gro&szlig;en Posten dar, den Sie in Ihrer Einkommensteuererkl&auml;rung geltend machen k&ouml;nnen. Dieses Merkblatt gibt Ihnen Aufschluss &uuml;ber die M&ouml;glichkeiten und Grenzen beim Sonderausgabenabzug.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=sonderausgaben_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt266"></a><a class="merkblatt" href="javascript:toggleDiv('mb_266');">Steuerentlastungen 2023</a><div id="mb_266" class="mb_teaser" style="display:none;"><p class="mb_teaser">Das Steuerrecht sieht auch f&uuml;r das Jahr 2023 verschiedene Entlastungen f&uuml;r Steuerpflichtige vor. In diesem Merkblatt erfahren Sie, worauf Sie jetzt achten m&uuml;ssen!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=steuerentlastungen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt14"></a><a class="merkblatt" href="javascript:toggleDiv('mb_14');">Vereine</a><div id="mb_14" class="mb_teaser" style="display:none;"><p class="mb_teaser">Vereine stellen einen Mittelpunkt des sozialen Lebens in Deutschland dar, daher werden viele als gemeinn&uuml;tzig eingestuft und genie&szlig;en steuerliche Vorteile. Damit Sie diese f&uuml;r Ihren Verein optimal nutzen k&ouml;nnen, haben wir f&uuml;r Sie die wichtigsten Punkte herausgearbeitet.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=vereine_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt15"></a><a class="merkblatt" href="javascript:toggleDiv('mb_15');">Vertr&auml;ge zwischen nahen Angeh&ouml;rigen</a><div id="mb_15" class="mb_teaser" style="display:none;"><p class="mb_teaser">Bei Vertr&auml;gen mit Angeh&ouml;rigen sind g&uuml;nstige Konditionen &uuml;blich &ndash; es bleibt ja in der Familie. Weil dabei oftmals auch steuerliche Vorteile entstehen, wirft der Fiskus auf diese Vertr&auml;ge ein scharfes Auge! Mit Hilfe dieses Merkblatts k&ouml;nnen Sie Ihre M&ouml;glichkeiten nutzen und Ihre Risiken minimieren.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=vertraege_zwischen_angehoerigen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt16"></a><a class="merkblatt" href="javascript:toggleDiv('mb_16');">Wohn-Riester</a><div id="mb_16" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die kapitalgedeckte Altersvorsorge (oder einfacher: Riester-Rente) bietet auch die M&ouml;glichkeit, staatliche F&ouml;rderungen f&uuml;r die Finanzierung von Immobilien oder Dauerwohnrechten zu erlangen. Informieren Sie sich &uuml;ber Ihre M&ouml;glichkeiten mit diesem Merkblatt!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=wohn_riester_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li></ul></div></div><div class="rubrik_container"><div class = "rubrik_header" id="rubrik_header2"><div id="hg_2" class="rubrikbild_hg"><img class="rubrikbild" id="icon_2" src="https://www.deubner-online.de/einbau/mmo/merkblattpages/images/icon_ag_an1.png"></div><div class="rubrik"><a href="javascript:toggleRubrikDiv('rubrik_2', 2, 1);"><h5 class="rubrik_n">Arbeitgeber und Arbeitnehmer</h5></a></div></div>
						<div id="rubrik_2" style="display:block;" ><ul><li class="merkblattzeile"><a class="anker" name="merkblatt138"></a><a class="merkblatt" href="javascript:toggleDiv('mb_138');">Fahrzeugnutzung durch Arbeitnehmer</a><div id="mb_138" class="mb_teaser" style="display:none;"><p class="mb_teaser">Sie sehen einen privat nutzbaren Dienstwagen sicherlich als praktische Zusatzleistung des Arbeitgebers. Der Fiskus sieht darin jedoch Arbeitslohn, der versteuert werden muss! Hier erfahren Sie alles &uuml;ber Ihre steuerlichen M&ouml;glichkeiten, anschaulich anhand von Rechenbeispielen erl&auml;utert.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=fahrzeugnutzung_arbeitnehmer_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt128"></a><a class="merkblatt" href="javascript:toggleDiv('mb_128');">Elektronische &Uuml;bermittlung von Steuererkl&auml;rungen</a><div id="mb_128" class="mb_teaser" style="display:none;"><p class="mb_teaser">Unternehmer sind schon seit Jahren verpflichtet, das ELSTER-Verfahren zu nutzen. Auch bei privaten Steuererkl&auml;rungen setzt sich das Verfahren mehr und mehr durch. Das Merkblatt lotst Sie durch den komplizierten Registrierungsprozess und kl&auml;rt Sie &uuml;ber Ihre Pflichten auf.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=elektr_uebermittlung_steuererklaerungen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt124"></a><a class="merkblatt" href="javascript:toggleDiv('mb_124');">Betriebliche Altersversorgung</a><div id="mb_124" class="mb_teaser" style="display:none;"><p class="mb_teaser">Eine betriebliche Altersversorgung lohnt sich! Arbeitnehmer profitieren im Alter von einer zus&auml;tzlichen Absicherung, und Arbeitgeber k&ouml;nnen die Lohnnebenkosten sp&uuml;rbar senken. Das Merkblatt stellt die verschiedenen Versicherungsmodelle und ihre jeweiligen Vorteile vor.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=betriebliche_altersverorgung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt229"></a><a class="merkblatt" href="javascript:toggleDiv('mb_229');">A1-Bescheinigung</a><div id="mb_229" class="mb_teaser" style="display:none;"><p class="mb_teaser">Auch eine nur vor&uuml;bergehende Erwerbst&auml;tigkeit im EU- bzw. EWR-Ausland oder der Schweiz erfordert eine - auf Meldung des Arbeitgebers ausgestellte - A1-Bescheinigung, und zwar als Nachweis des Arbeitnehmers f&uuml;r die Freistellung von den am Besch&auml;ftigungsort geltenden Sozialversicherungsbestimmungen. Alle Details dazu erfahren Sie in diesem Merkblatt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=a1_bescheinigung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt122"></a><a class="merkblatt" href="javascript:toggleDiv('mb_122');">Arbeitszeitregelungen</a><div id="mb_122" class="mb_teaser" style="display:none;"><p class="mb_teaser">Wie lange d&uuml;rfen Arbeitnehmer t&auml;glich arbeiten? Und w&ouml;chentlich? Sind Bereitschaftsdienste Arbeitszeit? Wann sind Pausen einzulegen, und wie lange? Zu diesen und vielen anderen Fragen rund um die Arbeitszeit finden Sie hier die Antwort.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=arbeitszeitregelungen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt123"></a><a class="merkblatt" href="javascript:toggleDiv('mb_123');">Beruflich genutztes Arbeitszimmer</a><div id="mb_123" class="mb_teaser" style="display:none;"><p class="mb_teaser">Geh&ouml;ren Sie zu den Gl&uuml;cklichen, die von zu Hause aus arbeiten? Haben Sie dazu ein separates Zimmer als Arbeitsplatz eingerichtet? Dieses Merkblatt erkl&auml;rt, ob und in welcher H&ouml;he Sie die Kosten daf&uuml;r steuerlich ansetzen k&ouml;nnen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=beruflich_genutztes_arbeitszimmer_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt125"></a><a class="merkblatt" href="javascript:toggleDiv('mb_125');">Besch&auml;ftigung von Sch&uuml;lern und Studenten</a><div id="mb_125" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die Besch&auml;ftigung von Studenten und Sch&uuml;lern ist in vielen Unternehmen &uuml;blich, jedoch m&uuml;ssen dabei im Hinblick auf Lohnsteuer, Sozialversicherung und Arbeitsrecht spezielle Regeln beachtet werden. In diesem Merkblatt finden Sie die wichtigen Fakten zusammengefasst.
<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=beschaeftigung_schueler_studenten_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt140"></a><a class="merkblatt" href="javascript:toggleDiv('mb_140');">Besteuerung der Rentner und Pension&auml;re</a><div id="mb_140" class="mb_teaser" style="display:none;"><p class="mb_teaser">Seit 2005 sind auch Renteneink&uuml;nfte teilweise steuerpflichtig. Weil ihre Rente den Grundfreibetrag &uuml;bersteigt, m&uuml;ssen seitdem immer mehr Rentner eine Einkommensteuererkl&auml;rung abgeben. Das Merkblatt erkl&auml;rt die komplizierte Berechnung und sch&uuml;tzt Sie vor hohen Steuernachforderungen.
<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=besteuerung_rentner_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt126"></a><a class="merkblatt" href="javascript:toggleDiv('mb_126');">Bildungskosten f&uuml;r Beruf und Studium</a><div id="mb_126" class="mb_teaser" style="display:none;"><p class="mb_teaser">Bildung ist kein g&uuml;nstiges Gut, und da heutzutage viele Berufe eine st&auml;ndige Weiterbildung erfordern, fallen daf&uuml;r h&auml;ufig wiederkehrende Kosten an. Wie Sie Ihre Aus- und Fortbildungskosten in der Einkommensteuer geltend machen, erfahren Sie hier. <br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=bildungskosten_beruf_studium_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt234"></a><a class="merkblatt" href="javascript:toggleDiv('mb_234');">Corona-Krise und Virusepidemien</a><div id="mb_234" class="mb_teaser" style="display:none;"><p class="mb_teaser">Kurzarbeit, Lohnfortzahlung, Quarantäne: Eine Virusepidemie macht auch vor Unternehmen nicht halt! Dieses Merkblatt zeigt Ihnen, was Sie jetzt unbedingt beachten müssen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=corona_krise_und_virusepidemien_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt127"></a><a class="merkblatt" href="javascript:toggleDiv('mb_127');">Doppelte Haushaltsf&uuml;hrung</a><div id="mb_127" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die heutige Arbeitswelt erfordert eine hohe Mobilit&auml;t von Arbeitnehmern, daher ist es keine Seltenheit, dass eine zweite Wohnung in Arbeitsn&auml;he unterhalten wird. Welche Kosten Sie in Ihrer Steuererkl&auml;rung geltend machen k&ouml;nnen, erfahren Sie in diesem Merkblatt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=doppelte_haushaltsfuehrung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt215"></a><a class="merkblatt" href="javascript:toggleDiv('mb_215');">Fl&uuml;chtlinge als Arbeitnehmer</a><div id="mb_215" class="mb_teaser" style="display:none;"><p class="mb_teaser">Wie k&ouml;nnen Fl&uuml;chtlinge im eigenen Unternehmen angestellt werden? Was ist dabei zu beachten, wie ist der Ablauf? In diesem Merkblatt finden Sie alles Wissenswerte dazu.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=fluechtlinge_als_arbeitnehmer_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt235"></a><a class="merkblatt" href="javascript:toggleDiv('mb_235');">F&uuml;hrung eines Fahrtenbuchs</a><div id="mb_235" class="mb_teaser" style="display:none;"><p class="mb_teaser">Ein fehlendes oder unzureichend geführtes Fahrtenbuch ist einer der häufigsten Mängel, die von Betriebsprüfern moniert werden. Geben Sie diesen keine Chance! Hier finden sie alle Fakten rund um das Fahrtenbuch, ergänzt durch viele Checklisten.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=fuehrung_fahrtenbuch_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt225"></a><a class="merkblatt" href="javascript:toggleDiv('mb_225');">Geschenke, Bewirtungen und Betriebsveranstaltungen</a><div id="mb_225" class="mb_teaser" style="display:none;"><p class="mb_teaser">Kleine Geschenke erhalten die Freundschaft, auch wenn diese gesch&auml;ftlicher Natur ist. Doch was ist steuerlich zu beachten, wenn man Gesch&auml;ftspartner oder Mitarbeiter mit Aufmerksamkeiten bedenken bzw. mit Speis und Trank versorgen will? In diesem Merkblatt finden Sie alle Antworten und viele Gestaltungsm&ouml;glichkeiten.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=geschenke_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt131"></a><a class="merkblatt" href="javascript:toggleDiv('mb_131');">Gutscheine und Tankkarten</a><div id="mb_131" class="mb_teaser" style="display:none;"><p class="mb_teaser">Neben der &bdquo;Lohnt&uuml;te&ldquo; nutzen Arbeitgeber immer h&auml;ufiger Sachzuwendungen, um Arbeitnehmern zus&auml;tzliche Anreize zu bieten. Als &bdquo;Gehaltserh&ouml;hung&ldquo; eingesetzt, l&auml;sst sich dadurch Ihre Steuer- und Sozialabgabenlast senken. Wie Sie diese M&ouml;glichkeit nutzen k&ouml;nnen, erfahren Sie hier!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=gutscheine_und_tankkarten_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt243"></a><a class="merkblatt" href="javascript:toggleDiv('mb_243');">Homeoffice</a><div id="mb_243" class="mb_teaser" style="display:none;"><p class="mb_teaser">Das Arbeiten von zu Hause aus ist auf dem Vormarsch. Doch wie sieht es z.B. mit Datenschutz, rechtlichen Grundlagen oder steuerlichen Vergünstigungen aus? Dieses Merkblatt erklärt Ihnen, worauf Sie als Arbeitgeber oder Arbeitnehmer beim Homeoffice unbedingt achten sollten.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=homeoffice_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt132"></a><a class="merkblatt" href="javascript:toggleDiv('mb_132');">Hotel&uuml;bernachtung: Umsatzsteuerliche Besonderheiten</a><div id="mb_132" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die Unterscheidung zwischen dem erm&auml;&szlig;igten und dem Regelsatz wirft bei der Umsatzsteuer immer wieder Fragen auf. Gerade bei Hotelleistungen ist die Differenzierung oftmals schwierig. Damit Sie nicht den &Uuml;berblick verlieren, finden Sie hier anschaulich den Sachverhalt erkl&auml;rt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=hoteluebernachtung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt133"></a><a class="merkblatt" href="javascript:toggleDiv('mb_133');">Incentives</a><div id="mb_133" class="mb_teaser" style="display:none;"><p class="mb_teaser">Kleine Geschenke erhalten die Freundschaft, gro&szlig;e Geschenke senken den Gewinn &ndash; oder nicht? Finden Sie anhand dieses Merkblatts heraus, welche M&ouml;glichkeiten und welche Grenzen bei der steuerlichen Ber&uuml;cksichtigung von Incentives bestehen!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=incentives_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt271"></a><a class="merkblatt" href="javascript:toggleDiv('mb_271');">Inflationsausgleichspr&auml;mie</a><div id="mb_271" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die Inflationsausgleichspr&auml;mie erm&ouml;glicht Arbeitgebern, eine steuer- und sozialversicherungsfreie Zahlung an Arbeitnehmer in H&ouml;he von maximal 3.000 &#128; zu leisten. In diesem Merkblatt erfahren Sie, welche Voraussetzungen f&uuml;r die steuerfreie Zahlung der Pr&auml;mie vorliegen m&uuml;ssen und welche Besonderheiten zu beachten sind.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=inflationsausgleichspraemie_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt278"></a><a class="merkblatt" href="javascript:toggleDiv('mb_278');">Jobticket und Deutschlandticket: Steuerliche Aspekte</a><div id="mb_278" class="mb_teaser" style="display:none;"><p class="mb_teaser">Mit einem Jobticket und dem neu eingef&uuml;hrten Deutschlandticket k&ouml;nnen Arbeitgeber und Arbeitnehmer sparen. In diesem Merkblatt erfahren Sie alles, was Sie &uuml;ber die steuer- und sozialversicherungsfreie Nutzung eines Jobtickets wissen m&uuml;ssen!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=jobticket_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt241"></a><a class="merkblatt" href="javascript:toggleDiv('mb_241');">Kurzarbeitergeld</a><div id="mb_241" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die Anordnung von Kurzarbeit und die Zahlung von Kurzarbeitergeld kann Betriebe entlasten, die sonst Kündigungen aussprechen oder komplett schließen müssten. Dieses Merkblatt zeigt Ihnen, was Sie als Arbeitgeber bei der Kurzarbeit und dem Kurzarbeitergeld beachten müssen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=kurzarbeitergeld_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt134"></a><a class="merkblatt" href="javascript:toggleDiv('mb_134');">Lohnsteuerklassen - Faktorverfahren</a><div id="mb_134" class="mb_teaser" style="display:none;"><p class="mb_teaser">In der Regel ist es besser, schon im Vorfeld mehr Netto vom Brutto zu haben, als zu viel gezahlte Steuern erst nach einem Jahr zur&uuml;ckzubekommen. Hier erfahren Sie, welche Steuerklassenkombinationen m&ouml;glich sind und welche Wahl f&uuml;r Sie die g&uuml;nstigste ist.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=lohnsteuerklassen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt135"></a><a class="merkblatt" href="javascript:toggleDiv('mb_135');">Mindestlohn</a><div id="mb_135" class="mb_teaser" style="display:none;"><p class="mb_teaser">Der gesetzliche Mindestlohn wirft viele Fragen auf, unter anderen: Wie berechne ich einen Stundenlohn bei St&uuml;cklohn? Wer bekommt den Mindestlohn? Welche Ausnahmen existieren? Und muss ich meine Dienstleister &uuml;berwachen? Hier finden Sie die Antworten.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=mindestlohn_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt136"></a><a class="merkblatt" href="javascript:toggleDiv('mb_136');">Minijobber und Aushilfskr&auml;fte</a><div id="mb_136" class="mb_teaser" style="display:none;"><p class="mb_teaser">Aus der Arbeitswelt sind geringf&uuml;gig Besch&auml;ftigte und saisonale Aushilfskr&auml;fte nicht mehr wegzudenken. Allerdings m&uuml;ssen Sie bei diesen Besch&auml;ftigungsformen viele Besonderheiten beachten: Behalten Sie den &Uuml;berblick mit Hilfe dieses Merkblatts!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=minijobber_aushilfskraefte_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt137"></a><a class="merkblatt" href="javascript:toggleDiv('mb_137');">Mitarbeiterbeteiligung</a><div id="mb_137" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die eigenen Mitarbeiter an seinem Unternehmen zu beteiligen, ist in mehrerer Hinsicht von Vorteil: Es steigert das Zugeh&ouml;rigkeitsgef&uuml;hl in der Belegschaft und ist durch die m&ouml;gliche Steuer- und Sozialabgabenfreiheit auch gut f&uuml;r die Lohnnebenkosten. Erfahren Sie hier mehr.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=mitarbeiterbeteiligung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt139"></a><a class="merkblatt" href="javascript:toggleDiv('mb_139');">Reisekosten</a><div id="mb_139" class="mb_teaser" style="display:none;"><p class="mb_teaser">Wenn einer eine Dienstreise tut, dann hat er was zu erz&auml;hlen - unter anderem &uuml;ber die komplizierten Regelungen im Steuerrecht, wie Reisekosten steuermindernd geltend gemacht werden k&ouml;nnen. Dieses Merkblatt versetzt Sie in die Lage, diese M&ouml;glichkeiten optimal zu nutzen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=reisekosten_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt141"></a><a class="merkblatt" href="javascript:toggleDiv('mb_141');">Scheinselbst&auml;ndigkeit</a><div id="mb_141" class="mb_teaser" style="display:none;"><p class="mb_teaser">Wenn Selbst&auml;ndige nur f&uuml;r einen Auftraggeber t&auml;tig sind, h&auml;ngt immer &uuml;ber beiden Vertragspartnern das Damoklesschwert der Scheinselbst&auml;ndigkeit. Gehen Sie auf Nummer sicher und informieren Sie sich &uuml;ber die steuer- und sozialversicherungsrechtlichen Folgen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=scheinselbstaendigkeit_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt218"></a><a class="merkblatt" href="javascript:toggleDiv('mb_218');">Sozialversicherungen</a><div id="mb_218" class="mb_teaser" style="display:none;"><p class="mb_teaser">Welche Sozialversicherungen gibt es, was charakterisiert sie im Einzelnen, wer ist sozialversicherungspflichtig, wie lassen sich Beitr&auml;ge steuerlich geltend machen und wieso ist das ein wichtiges Thema f&uuml;r Arbeitnehmer ebenso wie f&uuml;r Unternehmer? Antworten gibt dieses Merkblatt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=sozialversicherungen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt267"></a><a class="merkblatt" href="javascript:toggleDiv('mb_267');">Steuerentlastungen 2023</a><div id="mb_267" class="mb_teaser" style="display:none;"><p class="mb_teaser">Das Steuerrecht sieht auch f&uuml;r das Jahr 2023 verschiedene Entlastungen f&uuml;r Steuerpflichtige vor. In diesem Merkblatt erfahren Sie, worauf Sie jetzt achten m&uuml;ssen!
<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=steuerentlastungen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt142"></a><a class="merkblatt" href="javascript:toggleDiv('mb_142');">Steuerg&uuml;nstige Gehaltszuwendungen</a><div id="mb_142" class="mb_teaser" style="display:none;"><p class="mb_teaser">Bei Arbeitnehmern ist ein h&ouml;heres Nettogehalt nat&uuml;rlich immer gern gesehen, aber auch der Arbeitgeber kann durch kluge Gestaltung von Gehaltszuwendungen seine Sozialversicherungslast reduzieren. Hier finden Sie 22 M&ouml;glichkeiten, die in Frage kommen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=steuerguenstige_gehaltszuwendungen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt269"></a><a class="merkblatt" href="javascript:toggleDiv('mb_269');">Transparente Arbeitsbedingungen</a><div id="mb_269" class="mb_teaser" style="display:none;"><p class="mb_teaser">Zum 01.08.2022 trat das Gesetz zur Umsetzung der Richtlinie (EU) 2019/1152 in Kraft und führte zu weitreichenden Änderungen im Nachweisgesetz. Dadurch sollen transparente und vorhersehbare Arbeitsbedingungen geschaffen werden. Sie als Arbeitgeber sollten diese Änderungen unbedingt kennen, denn Verstöße können mit hohen Bußgeldern geahndet werden!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=transparente_arbeitsbedingungen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt143"></a><a class="merkblatt" href="javascript:toggleDiv('mb_143');">Verlust des Arbeitsplatzes</a><div id="mb_143" class="mb_teaser" style="display:none;"><p class="mb_teaser">&bdquo;Hire and Fire&ldquo; ist in Deutschland nicht &uuml;blich, daher sollten Sie als Arbeitnehmer bei K&uuml;ndigungen schon sehr genau hinsehen, ob hier alles rechtens ist. Mit diesem Merkblatt verschaffen Sie sich den &Uuml;berblick &uuml;ber die Punkte, auf die Sie achten sollten.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=verlust_arbeitsplatz_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt144"></a><a class="merkblatt" href="javascript:toggleDiv('mb_144');">Vertr&auml;ge zwischen nahen Angeh&ouml;rigen</a><div id="mb_144" class="mb_teaser" style="display:none;"><p class="mb_teaser">Bei Vertr&auml;gen mit Angeh&ouml;rigen sind g&uuml;nstige Konditionen &uuml;blich &ndash; es bleibt ja in der Familie. Auch steuerlich k&ouml;nnen Vorteile entstehen, daher wirft der Fiskus auf diese Vertr&auml;ge ein scharfes Auge! Mit Hilfe dieses Merkblatts k&ouml;nnen Sie Ihre M&ouml;glichkeiten, aber auch Ihre Risiken erkennen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=vertraege_zwischen_angehoerigen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li></ul></div></div><div class="rubrik_container"><div class = "rubrik_header" id="rubrik_header3"><div id="hg_3" class="rubrikbild_hg"><img class="rubrikbild" id="icon_3" src="https://www.deubner-online.de/einbau/mmo/merkblattpages/images/icon_hausbesitzer1.png"></div><div class="rubrik"><a href="javascript:toggleRubrikDiv('rubrik_3', 3, 1);"><h5 class="rubrik_n">Hausbesitzer</h5></a></div></div>
						<div id="rubrik_3" style="display:block;" ><ul><li class="merkblattzeile"><a class="anker" name="merkblatt44"></a><a class="merkblatt" href="javascript:toggleDiv('mb_44');">Hausbesitzer&nbsp;&nbsp;<span class="update">[Update]</span></a><div id="mb_44" class="mb_teaser" style="display:none;"><p class="mb_teaser">Ob als selbst genutztes Eigenheim oder renditetr&auml;chtiges Mietshaus: Immobilien spielen f&uuml;r die Deutschen eine immer gr&ouml;&szlig;ere Rolle, denn rund die H&auml;lfte ihres Verm&ouml;gens haben sie in Grundbesitz angelegt. Hausbesitzer k&ouml;nnen sich mit diesem Merkblatt &uuml;ber s&auml;mtliche steuerlichen Aspekte rund um den Immobilienbesitz informieren.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=hausbesitzer_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt198"></a><a class="merkblatt" href="javascript:toggleDiv('mb_198');">Photovoltaikanlagen</a><div id="mb_198" class="mb_teaser" style="display:none;"><p class="mb_teaser">Wenn Sie Solarstrom in das &ouml;ffentliche Netz speisen, gelten auch Sie als &bdquo;Energieunternehmen&ldquo; &ndash; mit allen steuerlichen Auswirkungen, die dadurch entstehen. Behalten Sie mit diesem Merkblatt den &Uuml;berblick &uuml;ber Ihre Pflichten.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=photovoltaikanlagen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt236"></a><a class="merkblatt" href="javascript:toggleDiv('mb_236');">Energetische Sanierung nach &sect; 35c EStG</a><div id="mb_236" class="mb_teaser" style="display:none;"><p class="mb_teaser">Im Rahmen des Klimaschutzprogramms 2030 wurde § 35c ins Einkommensteuergesetz eingeführt. Diese Norm gilt seit dem 01.01.2020 und bietet Ihnen steuerliche Entlastungen bei der energetischen Sanierung Ihres selbstgenutzten Wohngebäudes. Unser Merkblatt zeigt Ihnen, wie Sie von dieser neuen Regelung profitieren und was Sie dabei beachten müssen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=energetische_sanierung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt285"></a><a class="merkblatt" href="javascript:toggleDiv('mb_285');">Eink&uuml;nfte aus Vermietung und Verpachtung</a><div id="mb_285" class="mb_teaser" style="display:none;"><p class="mb_teaser">Vermietungseink&uuml;nfte sind dazu geeignet, &uuml;ber lange Zeit eine sichere und planbare Rendite zu erzielen. Gerade wenn Sie als neuer Vermieter zum ersten Mal Vermietungseink&uuml;nfte erzielen m&ouml;chten, erfahren Sie in diesem Merkblatt alles, was Sie zu den steuerlichen Besonderheiten wissen m&uuml;ssen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=einkuenfte_v_v_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt279"></a><a class="merkblatt" href="javascript:toggleDiv('mb_279');">Abgrenzung von Herstellungs- und Erhaltungskosten</a><div id="mb_279" class="mb_teaser" style="display:none;"><p class="mb_teaser">Anschaffungs- oder Herstellungskosten werden grunds&auml;tzlich &uuml;ber die Nutzungsdauer des Wirtschaftsguts abgeschrieben, w&auml;hrend Erhaltungsaufwendungen bereits im Jahr ihrer Entstehung steuerlich voll abzugsf&auml;hig sind. Dieses Merkblatt erkl&auml;rt Ihnen, wie Sie den Begriff der Anschaffungs- bzw. Herstellungskosten von dem der Erhaltungsaufwendungen abgrenzen k&ouml;nnen, und worauf Sie dabei achten m&uuml;ssen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=herstellungskosten_erhaltungsaufwand_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt207"></a><a class="merkblatt" href="javascript:toggleDiv('mb_207');">Bauabzugsteuer</a><div id="mb_207" class="mb_teaser" style="display:none;"><p class="mb_teaser">Zur Bek&auml;mpfung der Schwarzarbeit im Baugewerbe hat der Fiskus die Bauabzugsteuer ersonnen, damit die Auftraggeber die Steuern schon abf&uuml;hren, bevor Bauunternehmen bezahlt werden. Hier finden Sie, worauf Sie dabei achten sollten.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=bauabzugsteuer_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt42"></a><a class="merkblatt" href="javascript:toggleDiv('mb_42');">Ferienimmobilien</a><div id="mb_42" class="mb_teaser" style="display:none;"><p class="mb_teaser">Dieses Merkblatt gibt Ihnen Auskunft &uuml;ber s&auml;mtliche steuerlichen Aspekte von der Investitionsphase bis zum Besitzerwechsel, damit Sie mit Ihrer Ferienimmobilie s&auml;mtliche Verg&uuml;nstigungen in Anspruch nehmen und Nachteile fr&uuml;hzeitig vermeiden k&ouml;nnen!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=ferienimmobilien_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt297"></a><a class="merkblatt" href="javascript:toggleDiv('mb_297');">Grundsteuer ab 2025</a><div id="mb_297" class="mb_teaser" style="display:none;"><p class="mb_teaser">Das Bundesverfassungsgericht entschied 2018, dass die Bewertung von Grundst&uuml;cken im Rahmen der Grundsteuer mit dem Einheitswert verfassungswidrig ist und verpflichtete den Gesetzgeber, die Grundsteuer neu zu regeln. Was &auml;ndert sich mit dieser Neuregelung im Vergleich zur vorherigen Rechtslage und wie wird die neue Grundsteuer berechnet? In diesem Merkblatt erfahren Sie mehr!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=grundsteuer_2025_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt43"></a><a class="merkblatt" href="javascript:toggleDiv('mb_43');">Grundsteuererlass</a><div id="mb_43" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die Grundsteuer stellt eine erhebliche Belastung von Immobilienbesitzern dar, welche bei Leerstand von vermieteten Objekten nicht aufgefangen wird. Setzen Sie sich &uuml;ber Ihre M&ouml;glichkeiten, in solchen F&auml;llen die Grundsteuer wiederzuerlangen, mit diesem Merkblatt ins Bild!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=grundsteuererlass_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt208"></a><a class="merkblatt" href="javascript:toggleDiv('mb_208');">Haushaltsnahe Dienstleistungen</a><div id="mb_208" class="mb_teaser" style="display:none;"><p class="mb_teaser">Der Fiskus f&ouml;rdert haushaltsnahe Dienstleistungen und Handwerkerleistungen mit einem Steuerbonus. Das Merkblatt zeigt Ihnen &uuml;bersichtlich die M&ouml;glichkeiten, aber auch die Grenzen dieser Beg&uuml;nstigung auf.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=haushaltsnahe_dienstleistungen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt283"></a><a class="merkblatt" href="javascript:toggleDiv('mb_283');">Heizungsgesetz - GEG-Novelle</a><div id="mb_283" class="mb_teaser" style="display:none;"><p class="mb_teaser">Nach einer turbulenten Debatte hat das Heizungsgesetz endlich den Bundesrat passiert und tritt zum 01.01.2024 in Kraft. Insbesondere als Hauseigentümer erfahren Sie in diesem Merkblatt, wie die neuen Regelungen aussehen und welcher Handlungsbedarf für Sie besteht.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=heizungsgesetz_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt45"></a><a class="merkblatt" href="javascript:toggleDiv('mb_45');">Immobilien&uuml;bertragung</a><div id="mb_45" class="mb_teaser" style="display:none;"><p class="mb_teaser">In vielen F&auml;llen m&ouml;chten Immobilienbesitzer ihre Immobilien bereits zu Lebzeiten auf die k&uuml;nftigen Erben &uuml;bertragen, ohne auf die bisherigen Mieteinnahmen zu verzichten. Die Nie&szlig;brauch-Regelungen, die hier unter die Lupe genommen werden, erlauben dies.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=immobilienuebertragung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt211"></a><a class="merkblatt" href="javascript:toggleDiv('mb_211');">Liebhaberei und Gewinnerzielungsabsicht</a><div id="mb_211" class="mb_teaser" style="display:none;"><p class="mb_teaser">Hinter dem unschuldig klingenden Begriff der Liebhaberei steckt eine steuerliche Bedrohung, die bereits strauchelnden Steuerpflichtigen endg&uuml;ltig ein Bein stellen kann. Was es damit auf sich hat erfahren Sie in diesem Merkblatt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=liebhaberei_gewinnerzielungsabsicht_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt231"></a><a class="merkblatt" href="javascript:toggleDiv('mb_231');">Sonderabschreibung nach &sect; 7b EStG</a><div id="mb_231" class="mb_teaser" style="display:none;"><p class="mb_teaser">Im August 2019 wurde § 7b EStG eingeführt, der die Inanspruchnahme von Sonderabschreibungen für den Mietwohnungsneubau ermöglicht. Dieses Merkblatt erklärt Ihnen kompakt und übersichtlich alles, was sie zu dem neuen § 7b EStG wissen müssen. So können auch Sie von den Sonderabschreibungen profitieren!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=sonderabschreibung_7b_estg_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt46"></a><a class="merkblatt" href="javascript:toggleDiv('mb_46');">Vertr&auml;ge zwischen nahen Angeh&ouml;rigen</a><div id="mb_46" class="mb_teaser" style="display:none;"><p class="mb_teaser">Bei Vertr&auml;gen mit Angeh&ouml;rigen sind g&uuml;nstige Konditionen &uuml;blich &ndash; es bleibt ja in der Familie. Weil dabei oftmals auch steuerliche Vorteile entstehen, wirft der Fiskus auf diese Vertr&auml;ge ein scharfes Auge! Mit Hilfe dieses Merkblatts k&ouml;nnen Sie Ihre M&ouml;glichkeiten nutzen und Ihre Risiken minimieren.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=vertraege_zwischen_angehoerigen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt47"></a><a class="merkblatt" href="javascript:toggleDiv('mb_47');">Wohn-Riester</a><div id="mb_47" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die kapitalgedeckte Altersvorsorge (oder einfacher: Riester-Rente) bietet auch die M&ouml;glichkeit, staatliche F&ouml;rderungen f&uuml;r die Finanzierung von Immobilien oder Dauerwohnrechten zu erlangen. Informieren Sie sich &uuml;ber Ihre M&ouml;glichkeiten mit diesem Merkblatt!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=wohn_riester_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li></ul></div></div><div class="rubrik_container"><div class = "rubrik_header" id="rubrik_header4"><div id="hg_4" class="rubrikbild_hg"><img class="rubrikbild" id="icon_4" src="https://www.deubner-online.de/einbau/mmo/merkblattpages/images/icon_kapitalanleger1.png"></div><div class="rubrik"><a href="javascript:toggleRubrikDiv('rubrik_4', 4, 1);"><h5 class="rubrik_n">Kapitalanleger</h5></a></div></div>
						<div id="rubrik_4" style="display:block;" ><ul><li class="merkblattzeile"><a class="anker" name="merkblatt48"></a><a class="merkblatt" href="javascript:toggleDiv('mb_48');">Abgeltungsteuer</a><div id="mb_48" class="mb_teaser" style="display:none;"><p class="mb_teaser">Wurden Kapitalertr&auml;ge in der Vergangenheit noch mit der Einkommensteuer verrechnet, schl&auml;gt der Fiskus inzwischen mit dem Mittel der Abgeltungsteuer zu. Welche Nachteile daraus ggf. entstehen und welche Vorteile Sie nutzen k&ouml;nnen, erl&auml;utert dieses Merkblatt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=abgeltungsteuer_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt221"></a><a class="merkblatt" href="javascript:toggleDiv('mb_221');">InvStG 2018</a><div id="mb_221" class="mb_teaser" style="display:none;"><p class="mb_teaser">Durch die Investmentsteuerreform &auml;ndert sich das Besteuerungsrecht von Investmentfonds grundlegend - mit nicht zu vernachl&auml;ssigenden Auswirkungen. Wie diese aussehen und welche Gestaltungsm&ouml;glichkeiten Sie im Rahmen des neuen Rechts haben, dar&uuml;ber informiert Sie dieses Merkblatt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=invstg_2018_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt50"></a><a class="merkblatt" href="javascript:toggleDiv('mb_50');">Kapitallebensversicherung</a><div id="mb_50" class="mb_teaser" style="display:none;"><p class="mb_teaser">Kapitallebensversicherungen waren lange Zeit eine beliebte Form der Altersvorsorge. Durch &Auml;nderungen im Steuerrecht haben sie aber an Attraktivit&auml;t verloren. Mit diesem Merkblatt k&ouml;nnen Sie sich &uuml;ber die Entwicklungen informieren.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=kapitallebensversicherung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt109"></a><a class="merkblatt" href="javascript:toggleDiv('mb_109');">Kontrollen bei Kapitalanlagen und Selbstanzeige</a><div id="mb_109" class="mb_teaser" style="display:none;"><p class="mb_teaser">Viele Nachrichten &uuml;ber Steuerhinterziehungsprozesse machen einem klar, dass es inzwischen schwer ist, dem Fiskus effektiv auszuweichen. Mit Hilfe dieses Merkblatts verschaffen Sie sich einen &Uuml;berblick &uuml;ber die Kontrollm&ouml;glichkeiten des Fiskus und die strafbefreiende Selbstanzeige.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=kontrollen_bei_kapitalanlagen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li></ul></div></div><div class="rubrik_container"><div class = "rubrik_header" id="rubrik_header5"><div id="hg_5" class="rubrikbild_hg"><img class="rubrikbild" id="icon_5" src="https://www.deubner-online.de/einbau/mmo/merkblattpages/images/icon_unternehmer1.png"></div><div class="rubrik"><a href="javascript:toggleRubrikDiv('rubrik_5', 5, 1);"><h5 class="rubrik_n">Unternehmer</h5></a></div></div>
						<div id="rubrik_5" style="display:block;" ><ul><li class="merkblattzeile"><a class="anker" name="merkblatt159"></a><a class="merkblatt" href="javascript:toggleDiv('mb_159');">Elektronische Rechnungen&nbsp;&nbsp;<span class="update">[Update]</span></a><div id="mb_159" class="mb_teaser" style="display:none;"><p class="mb_teaser">Zwar ist das papierlose B&uuml;ro immer noch eine Utopie, aber in der Rechnungsstellung werden digitale Rechnungen immer h&auml;ufiger. Worauf Sie sowohl bei der Erstellung als auch beim Erhalt von elektronischen Rechnungen achten sollten, erl&auml;utert dieses Merkblatt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=elektronische_rechnungen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt302"></a><a class="merkblatt" href="javascript:toggleDiv('mb_302');">Abgabe von Speisen und Getr&auml;nken ab 2026&nbsp;&nbsp;<span class="update">[Update]</span></a><div id="mb_302" class="mb_teaser" style="display:none;"><p class="mb_teaser">Das Umsatzsteuerrecht kennt beim Verkauf von direkt konsumierbaren Speisen viele Winkelz&uuml;ge und Sonderregelungen. Damit Sie hierbei nicht den &Uuml;berblick verlieren, finden Sie in diesem Merkblatt eine kompakte &Uuml;bersicht. (Rechtslage ab 01.01.2026)<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=abgabe_speisen_getraenke_2026_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt300"></a><a class="merkblatt" href="javascript:toggleDiv('mb_300');">Corona-Soforthilfe: R&uuml;ckforderungen&nbsp;&nbsp;<span class="update">[Update]</span></a><div id="mb_300" class="mb_teaser" style="display:none;"><p class="mb_teaser">Zu Beginn der Corona-Pandemie haben viele kleinere Unternehmen zur Bew&auml;ltigung von Liquidit&auml;tsengp&auml;ssen Soforthilfen erhalten. Nun ergehen in vielen F&auml;llen R&uuml;ckforderungsbescheide, bei denen gezahlte Hilfen zur&uuml;ckverlangt werden. Dieses Merkblatt bietet Ihnen einen &Uuml;berblick &uuml;ber den Ablauf, beantwortet typische Fragen und enth&auml;lt praktische Hinweise zum weiteren Vorgehen - inkl. praktischer Checkliste.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=corona_soforthilfe_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt145"></a><a class="merkblatt" href="javascript:toggleDiv('mb_145');">Abgabe von Speisen und Getr&auml;nken bis 2025&nbsp;&nbsp;<span class="update">[Update]</span></a><div id="mb_145" class="mb_teaser" style="display:none;"><p class="mb_teaser">Das Umsatzsteuerrecht kennt beim Verkauf von direkt konsumierbaren Speisen viele Winkelz&uuml;ge und Sonderregelungen. Damit Sie hierbei nicht den &Uuml;berblick verlieren, finden Sie in diesem Merkblatt eine kompakte &Uuml;bersicht.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=abgabe_speisen_getraenke_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt146"></a><a class="merkblatt" href="javascript:toggleDiv('mb_146');">Anforderungen an eine Rechnung</a><div id="mb_146" class="mb_teaser" style="display:none;"><p class="mb_teaser">Unvollst&auml;ndige Rechnungen f&uuml;hren regelm&auml;&szlig;ig zu Problemen mit dem Fiskus, sowohl beim Rechnungsersteller als auch beim Rechnungsempf&auml;nger. Dieses Merkblatt unterst&uuml;tzt Sie mit allen relevanten Informationen zur Rechnungserstellung und -kontrolle!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=anforderungen_an_rechnung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt193"></a><a class="merkblatt" href="javascript:toggleDiv('mb_193');">Arztpraxis und Vertragsarztzulassung</a><div id="mb_193" class="mb_teaser" style="display:none;"><p class="mb_teaser">Bei dem Erwerb einer Arztpraxis mit kassen&auml;rztlicher Zulassung besteht die Frage: Ist diese Zulassung ein immaterielles Wirtschaftsgut? Informieren Sie sich fr&uuml;hzeitig, damit Sie diesen Aspekt bereits vor dem Erwerb bedenken k&ouml;nnen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=arztpraxis_vertragsarztzulassung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt147"></a><a class="merkblatt" href="javascript:toggleDiv('mb_147');">Aufbewahrungspflichten</a><div id="mb_147" class="mb_teaser" style="display:none;"><p class="mb_teaser">Sp&auml;testens, wenn eine Betriebspr&uuml;fung einen tiefen Blick in Ihre Betriebsvorg&auml;nge wirft, m&uuml;ssen die n&ouml;tigen Unterlagen vorliegen. Dieses Merkblatt zeigt Ihnen auf, wann Sie welche Unterlagen vernichten d&uuml;rfen, ohne bei Betriebspr&uuml;fungen etwas bef&uuml;rchten zu m&uuml;ssen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=aufbewahrungspflichten_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt148"></a><a class="merkblatt" href="javascript:toggleDiv('mb_148');">Bauabzugsteuer</a><div id="mb_148" class="mb_teaser" style="display:none;"><p class="mb_teaser">Zur Bek&auml;mpfung der Schwarzarbeit im Baugewerbe hat der Fiskus die Bauabzugsteuer ersonnen, damit die Auftraggeber die Steuern schon abf&uuml;hren, bevor Bauunternehmen bezahlt werden. Hier finden Sie, worauf Sie dabei achten sollten.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=bauabzugsteuer_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt199"></a><a class="merkblatt" href="javascript:toggleDiv('mb_199');">Besteuerungsverfahren</a><div id="mb_199" class="mb_teaser" style="display:none;"><p class="mb_teaser">Der Weg von der Steuererkl&auml;rung &uuml;ber ein m&ouml;gliches Einspruchs- und Gerichtsverfahren hin zur Steuerfestsetzung und -erhebung: Hier finden Sie den Fahrplan und alle Aspekte, die Sie in den einzelnen Phasen beachten sollten.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=besteuerungsverfahren_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt209"></a><a class="merkblatt" href="javascript:toggleDiv('mb_209');">Betriebspr&uuml;fung</a><div id="mb_209" class="mb_teaser" style="display:none;"><p class="mb_teaser">Wenn sich das Finanzamt zur Betriebspr&uuml;fung ank&uuml;ndigt, sollten Sie so Einiges beachten. Hier finden Sie die n&ouml;tigen Informationen mit Checkliste, damit die Betriebspr&uuml;fung m&ouml;glichst reibungslos abl&auml;uft.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=betriebspruefung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt254"></a><a class="merkblatt" href="javascript:toggleDiv('mb_254');">Brexit &amp; Umsatzsteuer</a><div id="mb_254" class="mb_teaser" style="display:none;"><p class="mb_teaser">Zum 01.01.2021 wurde Großbritannien aus umsatzsteuerlicher Sicht vom EU-Mitgliedstaat zum Drittland. In diesem Merkblatt erfahren Sie alles, was Sie bei Warenlieferungen, Dienstleistungen und Handel mit Bezug zu Großbritannien umsatzsteuerlich beachten müssen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=brexit_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt152"></a><a class="merkblatt" href="javascript:toggleDiv('mb_152');">Buch- und Belegnachweise bei innergemeinschaftlichen Lieferungen</a><div id="mb_152" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die Umsatzsteuer bei grenz&uuml;berschreitenden Lieferungen gestaltet sich immer als fehleranf&auml;llig. Worauf Sie bei Lieferungen innerhalb der EU in Ihrer Dokumentation achten sollten, erl&auml;utert dieses Merkblatt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=buch_belegnachweise_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt153"></a><a class="merkblatt" href="javascript:toggleDiv('mb_153');">Buchf&uuml;hrungs- und bilanzierungspflichtige Mandanten</a><div id="mb_153" class="mb_teaser" style="display:none;"><p class="mb_teaser">Hier erfahren Sie, welche Unterlagen wir von Ihnen ben&ouml;tigen, um Ihre Buchf&uuml;hrung und Bilanzierung schnell und effizient &uuml;bernehmen zu k&ouml;nnen, und wie die Zusammenarbeit zwischen Ihnen und uns sich idealerweise gestaltet.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=buchfuehrungspflichtige_mandanten_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt237"></a><a class="merkblatt" href="javascript:toggleDiv('mb_237');">Corona-Krise und Virusepidemien</a><div id="mb_237" class="mb_teaser" style="display:none;"><p class="mb_teaser">Kurzarbeit, Lohnfortzahlung, Quarantäne: Eine Virusepidemie macht auch vor Unternehmen nicht halt! Dieses Merkblatt zeigt Ihnen, was Sie jetzt unbedingt beachten müssen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=corona_krise_und_virusepidemien_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt245"></a><a class="merkblatt" href="javascript:toggleDiv('mb_245');">Corona-Krise: Liquidit&auml;tshilfen</a><div id="mb_245" class="mb_teaser" style="display:none;"><p class="mb_teaser">Viele Unternehmen stehen aufgrund der Folgen der Corona-Krise vor dem Existenzaus – dem m&ouml;chte die Bundesregierung durch Soforthilfen entgegenwirken. In diesem Merkblatt erfahren Sie, welche Kredite und Hilfsprogramme f&uuml;r Sie zur Verf&uuml;gung stehen und wie Sie diese optimal nutzen!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=corona_krise_liquiditaetshilfen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt246"></a><a class="merkblatt" href="javascript:toggleDiv('mb_246');">Corona-Krise: Steuerliche Ma&szlig;nahmen</a><div id="mb_246" class="mb_teaser" style="display:none;"><p class="mb_teaser">Aufgrund der Corona-Krise stellen die laufenden Steuerzahlungen f&uuml;r betroffene Unternehmen eine hohe Belastung dar. Die Bundesregierung hat daher mehrere steuerliche Ma&szlig;nahmen beschlossen, um diese Belastung zu vermindern. Unser Merkblatt erl&auml;utert die Maßnahmen und deren Voraussetzungen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=corona_krise_steuerliche_massnahmen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt154"></a><a class="merkblatt" href="javascript:toggleDiv('mb_154');">Differenzbesteuerung</a><div id="mb_154" class="mb_teaser" style="display:none;"><p class="mb_teaser">Handeln Sie gewerblich mit gebrauchten Waren? Dann sind diese Informationen zur Differenzbesteuerung f&uuml;r Sie gedacht. Mit der Differenzbesteuerung k&ouml;nnen Sie den Umsatzsteuer-Nachteil, den Sie gegen&uuml;ber privaten Verk&auml;ufern erleiden, d&auml;mpfen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=differenzbesteuerung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt155"></a><a class="merkblatt" href="javascript:toggleDiv('mb_155');">Doppelte Haushaltsf&uuml;hrung</a><div id="mb_155" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die heutige Arbeitswelt erfordert eine hohe Mobilit&auml;t von Arbeitnehmern, daher ist es keine Seltenheit, dass eine zweite Wohnung in Arbeitsn&auml;he unterhalten wird. Welche Kosten Sie in Ihrer Steuererkl&auml;rung geltend machen k&ouml;nnen, erfahren Sie in diesem Merkblatt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=doppelte_haushaltsfuehrung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt222"></a><a class="merkblatt" href="javascript:toggleDiv('mb_222');">DSGVO</a><div id="mb_222" class="mb_teaser" style="display:none;"><p class="mb_teaser">Zwei Jahre nach Inkrafttreten der DSGVO werden deren Regelungen wirksam. Eine Missachtung kann zu hohen Bu&szlig;geldstrafen f&uuml;hren. Wer nicht zuletzt deshalb den Regelungen gen&uuml;gen will, der ben&ouml;tigt je nach Betriebsgr&ouml;&szlig;e durchaus Vorlauf. Mit diesem Merkblatt k&ouml;nnen Sie es angehen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=dsgvo_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt156"></a><a class="merkblatt" href="javascript:toggleDiv('mb_156');">E-Bilanz</a><div id="mb_156" class="mb_teaser" style="display:none;"><p class="mb_teaser">Sind Sie fit f&uuml;r die elektronische &Uuml;bermittlung Ihrer Bilanz? Erfahren Sie, ob sie von der &Uuml;bermittlungspflicht betroffen sind, was Sie &uuml;bermitteln m&uuml;ssen und welche Datenstruktur vorgeschrieben ist. Mit praktischer Checkliste f&uuml;r die optimale Vorbereitung!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=e_bilanz_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt160"></a><a class="merkblatt" href="javascript:toggleDiv('mb_160');">Elektronische &Uuml;bermittlung von Steuererkl&auml;rungen</a><div id="mb_160" class="mb_teaser" style="display:none;"><p class="mb_teaser">Als Unternehmer sind Sie verpflichtet, das ELSTER-Verfahren f&uuml;r Ihre Steuererkl&auml;rungen zu nutzen. Das Merkblatt lotst Sie durch den komplizierten Registrierungsprozess und kl&auml;rt Sie &uuml;ber Ihre Pflichten auf.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=elektr_uebermittlung_steuererklaerungen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt161"></a><a class="merkblatt" href="javascript:toggleDiv('mb_161');">Erbschaftsteuer: &Uuml;bertragung von Betriebsverm&ouml;gen</a><div id="mb_161" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die &Uuml;bertragung von Betriebsverm&ouml;gen erf&auml;hrt im Erbschaftsteuerrecht viele Verg&uuml;nstigungen, damit das Fortbestehen eines Unternehmens nicht durch einen Erbfall auf dem Spiel steht. Damit Sie bei diesem Thema den &Uuml;berblick bewahren, sind hier alle relevanten Fakten f&uuml;r Sie zusammengetragen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=erbschaftsteuer_uebertragung_betriebsvermoegen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt162"></a><a class="merkblatt" href="javascript:toggleDiv('mb_162');">Existenzgr&uuml;ndung</a><div id="mb_162" class="mb_teaser" style="display:none;"><p class="mb_teaser">Wenn Sie sich selbst&auml;ndig machen wollen, sollten Sie zur Vorbereitung dieses Merkblatt unbedingt lesen: Es informiert Sie &uuml;ber viele wichtige Themen, vom Unternehmensplan &uuml;ber Kapitalbeschaffungs- und F&ouml;rderma&szlig;nahmen bis hin zur Besteuerung von Unternehmen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=existenzgruendung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt180"></a><a class="merkblatt" href="javascript:toggleDiv('mb_180');">Fahrzeugnutzung durch Unternehmer</a><div id="mb_180" class="mb_teaser" style="display:none;"><p class="mb_teaser">Firmenfahrzeuge werden h&auml;ufig auch privat genutzt, sei es von Ihnen als Unternehmer oder von Ihren Angestellten. Wie Sie dies steuerlich darstellen, erfahren Sie hier - mit Berechnungsbeispielen und Hinweisen, worauf Sie dabei achten sollten.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=fahrzeugnutzung_unternehmer_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt192"></a><a class="merkblatt" href="javascript:toggleDiv('mb_192');">Fernverkaufsregelung</a><div id="mb_192" class="mb_teaser" style="display:none;"><p class="mb_teaser">Eine Lieferung wird im Normalfall dort steuerlich wirksam, wo sie beginnt. Innerhalb der EU kann dies jedoch nicht der Fall sein, da hier eine spezielle Versandhandelsregelung gilt. Machen Sie sich schlau und erfahren Sie, was es damit auf sich hat.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=fernverkaufsregelung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt163"></a><a class="merkblatt" href="javascript:toggleDiv('mb_163');">F&uuml;hrung eines Fahrtenbuchs</a><div id="mb_163" class="mb_teaser" style="display:none;"><p class="mb_teaser">Ein fehlendes oder unzureichend gef&uuml;hrtes Fahrtenbuch ist einer der h&auml;ufigsten M&auml;ngel, die von Betriebspr&uuml;fern moniert werden. Geben Sie diesen keine Chance! Hier finden sie alle Fakten rund um das Fahrtenbuch, erg&auml;nzt durch viele Checklisten.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=fuehrung_fahrtenbuch_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt216"></a><a class="merkblatt" href="javascript:toggleDiv('mb_216');">Gemeinn&uuml;tzige Gesellschaften</a><div id="mb_216" class="mb_teaser" style="display:none;"><p class="mb_teaser">Nicht immer ist der Verein die geeignete Rechtsform f&uuml;r gemeinn&uuml;tzige Organisationen. Hier erfahren Sie, wann eine gGmbH, eine gUG (haftungsbeschr&auml;nkt) oder eine Stiftung die bessere Wahl ist. Au&szlig;erdem erfahren Sie Grundlegendes &uuml;ber die drei genannten Gesellschaftsformen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=gemeinnuetzige_gesellschaften_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt165"></a><a class="merkblatt" href="javascript:toggleDiv('mb_165');">Geringwertige Wirtschaftsg&uuml;ter</a><div id="mb_165" class="mb_teaser" style="display:none;"><p class="mb_teaser">Abschreibungen &uuml;ber mehrere Jahre sind f&uuml;r viele Wirtschaftsg&uuml;ter aufgrund des geringen Werts nicht sinnvoll, daher erlaubt der Gesetzgeber in engen Grenzen die Abschreibung in einem einzigen Jahr. Welche M&ouml;glichkeiten dabei bestehen, erfahren Sie hier.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=geringwertige_wirtschaftsgueter_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt226"></a><a class="merkblatt" href="javascript:toggleDiv('mb_226');">Geschenke, Bewirtungen und Betriebsveranstaltungen</a><div id="mb_226" class="mb_teaser" style="display:none;"><p class="mb_teaser">Kleine Geschenke erhalten die Freundschaft, auch wenn diese gesch&auml;ftlicher Natur ist. Doch was ist steuerlich zu beachten, wenn man Gesch&auml;ftspartner oder Mitarbeiter mit Aufmerksamkeiten bedenken bzw. mit Speis und Trank versorgen will? In diesem Merkblatt finden Sie alle Antworten und viele Gestaltungsm&ouml;glichkeiten.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=geschenke_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt167"></a><a class="merkblatt" href="javascript:toggleDiv('mb_167');">GmbH &amp; Co. KG</a><div id="mb_167" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die GmbH &amp; Co. KG erfreut sich gerade bei Familienunternehmen und kleineren Gewerbebetrieben einer gro&szlig;en Beliebtheit. Dieses Merkblatt informiert Sie ausf&uuml;hrlich &uuml;ber alle relevanten Aspekte dieser Rechtsform.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=gmbh_und_cokg_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt170"></a><a class="merkblatt" href="javascript:toggleDiv('mb_170');">GmbH-Gesch&auml;ftsf&uuml;hrer</a><div id="mb_170" class="mb_teaser" style="display:none;"><p class="mb_teaser">Welche Rechte haben Sie als Gesch&auml;ftsf&uuml;hrer? Welche Pflichten? Und sind Sie pers&ouml;nlich haftbar? Hier finden Sie die Antworten auf viele Fragen, anschaulich beschrieben und um zahlreiche Hinweise f&uuml;r Ihre Praxis erg&auml;nzt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=gmbh_geschaeftsfuehrer_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt293"></a><a class="merkblatt" href="javascript:toggleDiv('mb_293');">GmbH-Holding&nbsp;&nbsp;<span class="update">[Update]</span></a><div id="mb_293" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die Nutzung einer Holding-GmbH kann steuerliche Vorteile bringen, allerdings nur unter engen Voraussetzungen. Ob sich eine Holdingstruktur auch f&uuml;r Sie lohnt, erfahren Sie in diesem Merkblatt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=gmbh_holding_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt169"></a><a class="merkblatt" href="javascript:toggleDiv('mb_169');">GmbH-Pensionszusagen</a><div id="mb_169" class="mb_teaser" style="display:none;"><p class="mb_teaser">Auf Pensionszusagen und gezahlte Pensionen richten die Pr&uuml;fer bei einer Betriebspr&uuml;fung h&auml;ufig ein besonderes Augenmerk. Damit Sie hier nicht in eine Falle tappen, haben wir f&uuml;r Sie in diesem Merkblatt die wichtigsten Fakten rund um Pensionszusagen zusammengestellt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=gmbh_pensionszusagen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt168"></a><a class="merkblatt" href="javascript:toggleDiv('mb_168');">GmbH: Aufl&ouml;sung, Liquidation und Beendigung</a><div id="mb_168" class="mb_teaser" style="display:none;"><p class="mb_teaser">Alles hat ein Ende, dies gilt auch f&uuml;r haftungsbeschr&auml;nkte Gesellschaften. Welche Schritte in diesem Fall ergriffen werden m&uuml;ssen und wie sich der regul&auml;re Verlauf vom Aufl&ouml;sungsgrund bis zur Beendigung darstellt, das erfahren Sie hier. <br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=gmbh_aufloesung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt158"></a><a class="merkblatt" href="javascript:toggleDiv('mb_158');">GoBD</a><div id="mb_158" class="mb_teaser" style="display:none;"><p class="mb_teaser">Was die Finanzverwaltung freut, m&uuml;ssen Unternehmer ausbaden: Immer mehr Vorschriften zur digitalen Buchf&uuml;hrung erfordern st&auml;ndige Anpassungen von Software und Gesch&auml;ftsprozessen. Erfahren Sie jetzt mehr &uuml;ber den neuesten digitalen Coup der Finanzverwaltung: die GoBD.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=gobd_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt244"></a><a class="merkblatt" href="javascript:toggleDiv('mb_244');">Homeoffice</a><div id="mb_244" class="mb_teaser" style="display:none;"><p class="mb_teaser">Das Arbeiten von zu Hause aus ist auf dem Vormarsch. Doch wie sieht es z.B. mit Datenschutz, rechtlichen Grundlagen oder steuerlichen Vergünstigungen aus? Dieses Merkblatt erklärt Ihnen, worauf Sie als Arbeitgeber oder Arbeitnehmer beim Homeoffice unbedingt achten sollten.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=homeoffice_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt171"></a><a class="merkblatt" href="javascript:toggleDiv('mb_171');">Hotel&uuml;bernachtung: Umsatzsteuerliche Besonderheiten</a><div id="mb_171" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die Unterscheidung zwischen dem erm&auml;&szlig;igten und dem Regelsatz wirft bei der Umsatzsteuer immer wieder Fragen auf. Gerade bei Hotelleistungen ist die Differenzierung oftmals schwierig. Damit Sie nicht den &Uuml;berblick verlieren, finden Sie hier anschaulich den Sachverhalt erkl&auml;rt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=hoteluebernachtung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt210"></a><a class="merkblatt" href="javascript:toggleDiv('mb_210');">Incentives</a><div id="mb_210" class="mb_teaser" style="display:none;"><p class="mb_teaser">Kleine Geschenke erhalten die Freundschaft, gro&szlig;e Geschenke senken den Gewinn &ndash; oder nicht? Finden Sie anhand dieses Merkblatts heraus, welche M&ouml;glichkeiten und welche Grenzen bei der steuerlichen Ber&uuml;cksichtigung von Incentives bestehen!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=incentives_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt173"></a><a class="merkblatt" href="javascript:toggleDiv('mb_173');">Insolvenz und Steuern</a><div id="mb_173" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die Insolvenz stellt einen deutlichen Einschnitt in die unternehmerische T&auml;tigkeit dar, welche auch in steuerlicher Hinsicht Wellen schl&auml;gt. Worauf Sie dabei achten m&uuml;ssen und welche M&ouml;glichkeiten f&uuml;r Sie bestehen, erfahren Sie hier.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=insolvenz_und_steuern_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt174"></a><a class="merkblatt" href="javascript:toggleDiv('mb_174');">Inventur</a><div id="mb_174" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die Inventur ist eine der wichtigsten Grundlagen einer sinnvollen Bewertung eines Unternehmens, daher haben wir f&uuml;r Sie die wichtigsten Begriffe, Inventurformen und -verfahren &uuml;bersichtlich zusammengefasst.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=inventur_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt175"></a><a class="merkblatt" href="javascript:toggleDiv('mb_175');">Investitionsabzugsbetrag</a><div id="mb_175" class="mb_teaser" style="display:none;"><p class="mb_teaser">Planen Sie eine gr&ouml;&szlig;ere Anschaffung f&uuml;r Ihr Unternehmen? Mit dem Investitionsabzugsbetrag er&ouml;ffnen sich Ihnen effektive Gestaltungsm&ouml;glichkeiten, um Ihre Steuerlast zu beeinflussen! Hier finden Sie alle wichtigen Informationen, um die Vor- und Nachteile abw&auml;gen zu k&ouml;nnen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=investitionsabzugsbetrag_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt299"></a><a class="merkblatt" href="javascript:toggleDiv('mb_299');">Investitionsbooster 2025</a><div id="mb_299" class="mb_teaser" style="display:none;"><p class="mb_teaser">Das Gesetz f&uuml;r ein steuerliches Investitionssofortprogramm setzt wichtige Impulse zur St&auml;rkung des Wirtschaftsstandorts Deutschland. Kernpunkte sind eine befristete degressive Abschreibung und neue F&ouml;rderungen f&uuml;r die Elektromobilit&auml;t. Informieren Sie sich mit diesem Merkblatt &uuml;ber alle Ma&szlig;nahmen dieses Investitionsboosters!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=investitionsbooster_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt262"></a><a class="merkblatt" href="javascript:toggleDiv('mb_262');">Kasse und Kassenpr&uuml;fung mit Checkliste</a><div id="mb_262" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die M&ouml;glichkeit der unangek&uuml;ndigten Kassennachschau und neue Versch&auml;rfungen durch das Kassengesetz setzen Unternehmer weiter unter Stress. In diesem Merkblatt erfahren Sie ganz praktisch die wichtigsten Infos zum Kassenkauf sowie die Anforderungen an bereits vorhandene Kassen. So bleiben Sie handlungsf&auml;hig.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=kasse_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt294"></a><a class="merkblatt" href="javascript:toggleDiv('mb_294');">Kleinunternehmerregelung bis 2024</a><div id="mb_294" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die Kleinunternehmerregelung bietet die M&ouml;glichkeit einer Vereinfachung der steuerlichen Pflichten, die eine Unternehmensgr&uuml;ndung mit sich bringt. Werden bestimmte Umsatzgrenzen nicht &uuml;berschritten, erm&ouml;glicht diese Regelung eine fast vollst&auml;ndige Befreiung von den umsatzsteuerlichen Pflichten. In diesem Merkblatt erfahren Sie, wie sie die Kleinunternehmerregelung nutzen k&ouml;nnen und welche Vor- aber auch Nachteile diese Regelung bietet.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=kleinunternehmerregelung_2024_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt295"></a><a class="merkblatt" href="javascript:toggleDiv('mb_295');">Kleinunternehmerregelung ab 2025</a><div id="mb_295" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die Kleinunternehmerregelung bietet die M&ouml;glichkeit einer Vereinfachung der steuerlichen Pflichten, die eine Unternehmensgr&uuml;ndung mit sich bringt. Werden bestimmte Umsatzgrenzen nicht &uuml;berschritten, erm&ouml;glicht diese Regelung eine fast vollst&auml;ndige Befreiung von den umsatzsteuerlichen Pflichten. In diesem Merkblatt erfahren Sie, wie sie die Kleinunternehmerregelung nutzen k&ouml;nnen und welche Vor- aber auch Nachteile diese Regelung bietet - inklusive aller Neuregelungen ab 2025!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=kleinunternehmerregelung_2025_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt249"></a><a class="merkblatt" href="javascript:toggleDiv('mb_249');">Konjunkturpaket 2020 - Zweites Corona-Steuerhilfegesetz</a><div id="mb_249" class="mb_teaser" style="display:none;"><p class="mb_teaser">Das zweite Corona-Steuerhilfegesetz setzt das Konjunkturpaket der Regierung um und enthält viele Regelungen, die die Wirtschaft nach der Corona-Krise wieder ankurbeln sollen. Dieses Merkblatt zeigt Ihnen, welche Regelungen für Unternehmer besonders wichtig sind.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=konjunkturpaket_2020_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt289"></a><a class="merkblatt" href="javascript:toggleDiv('mb_289');">Korrekturverfahren</a><div id="mb_289" class="mb_teaser" style="display:none;"><p class="mb_teaser">In der Praxis kommt es h&auml;ufig vor, dass ein erlassener Steuerbescheid fehlerhaft ist. Hier sieht die Abgabenordnung verschiedene M&ouml;glichkeiten vor, eine &Auml;nderung herbeizuf&uuml;hren. Dieses Merkblatt erl&auml;utert Ihnen, wie diese M&ouml;glichkeiten aussehen und was es hierbei zu beachten gibt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=korrekturverfahren_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt261"></a><a class="merkblatt" href="javascript:toggleDiv('mb_261');">Kryptow&auml;hrungen</a><div id="mb_261" class="mb_teaser" style="display:none;"><p class="mb_teaser">Kryptow&auml;hrungen, wie z.B. Bitcoin, haben mittlerweile schon eine &uuml;ber zehnj&auml;hrige Historie von Aufschwung und Abschwung hinter sich. Doch was sind Kryptow&auml;hrungen &uuml;berhaupt und wie k&ouml;nnen sie in Deutschland steuerlich eingeordnet werden? Dieses Merkblatt gibt Ihnen Antworten!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=kryptowaehrungen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt242"></a><a class="merkblatt" href="javascript:toggleDiv('mb_242');">Kurzarbeitergeld</a><div id="mb_242" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die Anordnung von Kurzarbeit und die Zahlung von Kurzarbeitergeld kann Betriebe entlasten, die sonst Kündigungen aussprechen oder komplett schließen müssten. Dieses Merkblatt zeigt Ihnen, was Sie als Arbeitgeber bei der Kurzarbeit und dem Kurzarbeitergeld beachten müssen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=kurzarbeitergeld_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt264"></a><a class="merkblatt" href="javascript:toggleDiv('mb_264');">K&ouml;MoG</a><div id="mb_264" class="mb_teaser" style="display:none;"><p class="mb_teaser">Das Gesetzgebungsverfahren des Gesetzes zur Modernisierung des K&ouml;rperschaftsteuerrechts (K&ouml;MoG) wurde im Eiltempo vorangetrieben, sodass die Neuregelungen bereits zum 01.01.2022 in Kraft treten. Das K&ouml;MoG regelt u.a. die Option zur K&ouml;rperschaftsbesteuerung f&uuml;r Personenhandelsgesellschaften und Partnerschaftsgesellschaften. In diesem Merkblatt erfahren Sie, was sie zu diesem Optionsmodell wissen m&uuml;ssen und wie sie es in der Praxis umsetzen k&ouml;nnen!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=koemog_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt176"></a><a class="merkblatt" href="javascript:toggleDiv('mb_176');">K&uuml;nstlersozialabgabe</a><div id="mb_176" class="mb_teaser" style="display:none;"><p class="mb_teaser">Auch freischaffende K&uuml;nstler unterstehen den Sozialversicherungen, und wenn Sie regelm&auml;&szlig;ig K&uuml;nstler engagieren, m&uuml;ssen Sie f&uuml;r diese auch einen Arbeitgeberanteil abf&uuml;hren. Diese &Uuml;bersicht wird Ihre Fragen zur K&uuml;nstlersozialkasse kl&auml;ren!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=kuenstlersozialabgabe_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt177"></a><a class="merkblatt" href="javascript:toggleDiv('mb_177');">Land- und Forstwirtschaft</a><div id="mb_177" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die Vorstellung vom &bdquo;einfachen Landleben&ldquo; ist selten realit&auml;tsnah &ndash; vor allem, wenn es um die Steuer geht. Unz&auml;hlige Sonderregeln machen die Steuern in der Land- und Forstwirtschaft un&uuml;bersichtlich. Dieses Merkblatt bietet Ihnen einen komprimierten &Uuml;berblick &uuml;ber die zentralen Steuergebiete.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=land_und_forstwirtschaft_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt212"></a><a class="merkblatt" href="javascript:toggleDiv('mb_212');">Liebhaberei und Gewinnerzielungsabsicht</a><div id="mb_212" class="mb_teaser" style="display:none;"><p class="mb_teaser">Hinter dem unschuldig klingenden Begriff der Liebhaberei steckt eine steuerliche Bedrohung, die bereits strauchelnden Steuerpflichtigen endg&uuml;ltig ein Bein stellen kann. Was es damit auf sich hat erfahren Sie in diesem Merkblatt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=liebhaberei_gewinnerzielungsabsicht_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt255"></a><a class="merkblatt" href="javascript:toggleDiv('mb_255');">Meldepflicht f&uuml;r grenz&uuml;berschreitende Steuergestaltungen</a><div id="mb_255" class="mb_teaser" style="display:none;"><p class="mb_teaser">Um der Ausnutzung internationaler Steuergestaltungen zur Senkung der Gesamtsteuerlast entgegenzuwirken, besteht nun eine Meldepflicht für grenzüberschreitende Steuergestaltungen. Dieses Merkblatt erklärt Ihnen, worum es genau geht und worauf Sie achten müssen, um einen Verstoß gegen die Meldepflicht und damit hohe Bußgelder zu vermeiden.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=grenzueberschreitende_steuergestaltungen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt298"></a><a class="merkblatt" href="javascript:toggleDiv('mb_298');">Meldung elektronischer Kassen</a><div id="mb_298" class="mb_teaser" style="display:none;"><p class="mb_teaser">Seit dem 01.01.2025 m&uuml;ssen elektronische Aufzeichnungssysteme nach &sect; 146a Abs. 4 AO verpflichtend dem Finanzamt gemeldet werden. Dieses Merkblatt bietet Ihnen eine Schritt-f&uuml;r-Schritt-Anleitung, damit die Kassenmeldung &uuml;ber das ELSTER-Portal ganz einfach gelingt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=meldung_elektronischer_kassen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt284"></a><a class="merkblatt" href="javascript:toggleDiv('mb_284');">MoPeG</a><div id="mb_284" class="mb_teaser" style="display:none;"><p class="mb_teaser">Am 01.01.2024 tritt das Gesetz zur Modernisierung des Personengesellschaftsrechts (MoPeG) in Kraft. Die Gesellschafter unter Ihren Mandanten erfahren hier, welche &Auml;nderungen und Neuerungen diese Reform mit sich bringt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=mopeg_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt179"></a><a class="merkblatt" href="javascript:toggleDiv('mb_179');">Nicht buchf&uuml;hrungspflichtige Mandanten</a><div id="mb_179" class="mb_teaser" style="display:none;"><p class="mb_teaser">Damit wir f&uuml;r Sie die steuerlich g&uuml;nstigsten L&ouml;sungen erarbeiten k&ouml;nnen, ben&ouml;tigen wir von Ihnen viele Informationen. Mit dieser &Uuml;bersicht verschaffen Sie sich den &Uuml;berblick, welche Unterlagen wir zu welchem Zeitpunkt ben&ouml;tigen und wozu diese dienen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=nicht_buchfuehrungspflichtige_mandanten_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt227"></a><a class="merkblatt" href="javascript:toggleDiv('mb_227');">Ordnungsgem&auml;&szlig;e Kassenf&uuml;hrung</a><div id="mb_227" class="mb_teaser" style="display:none;"><p class="mb_teaser">In den letzten Jahren ist viel Bewegung im Thema Kassenf&uuml;hrung, die Vorgaben seitens der Finanzbeh&ouml;rden wurden mehrfach ge&auml;ndert und zwar zuungunsten der Steuerpflichtigen. Hier erfahren Sie alles, was Sie zu dem Thema wissen m&uuml;ssen, u.a. was sich hinter Kassennachschau und Kassensicherungsverordnung verbirgt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=ordnungsgemaesse_kassenfuehrung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt257"></a><a class="merkblatt" href="javascript:toggleDiv('mb_257');">OSS-Verfahren</a><div id="mb_257" class="mb_teaser" style="display:none;"><p class="mb_teaser">Mit dem Mehrwertsteuer-Digitalpaket ergeben sich ab dem 01.07.2021 grundlegende Neuerungen im Umsatzsteuerrecht. So ist unter anderem ein neues Verfahren zur Abf&uuml;hrung von ausl&auml;ndischer Umsatzsteuer enthalten: der One-Stop-Shop (OSS). Hier finden Sie alles, was sie &uuml;ber die neuen Regelungen zum OSS-Verfahren wissen m&uuml;ssen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=oss_verfahren_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt200"></a><a class="merkblatt" href="javascript:toggleDiv('mb_200');">Photovoltaikanlagen</a><div id="mb_200" class="mb_teaser" style="display:none;"><p class="mb_teaser">Wenn Sie Solarstrom in das &ouml;ffentliche Netz speisen, gelten auch Sie als &bdquo;Energieunternehmen&ldquo; &ndash; mit allen steuerlichen Auswirkungen, die dadurch entstehen. Behalten Sie mit diesem Merkblatt den &Uuml;berblick &uuml;ber Ihre Pflichten.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=photovoltaikanlagen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt239"></a><a class="merkblatt" href="javascript:toggleDiv('mb_239');">Quick Fixes</a><div id="mb_239" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die EU-Mehrwertsteuerreform kommt – die ersten Änderungen gelten schon! Alle Unternehmen, die Warenbewegungen innerhalb der EU tätigen, sind von den Änderungen betroffen und müssen sie ab dem 01.01.2020 umsetzen. Informieren Sie sich daher umfassend und behalten Sie den Überblick mit Hilfe unseres Merkblatts!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=quick_fixes_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt280"></a><a class="merkblatt" href="javascript:toggleDiv('mb_280');">Reihengesch&auml;fte: Leitlinien f&uuml;r die Praxis</a><div id="mb_280" class="mb_teaser" style="display:none;"><p class="mb_teaser">Ein Reihengesch&auml;ft liegt vor, wenn mehrere Unternehmen &uuml;ber denselben Gegenstand Liefergesch&auml;fte abschlie&szlig;en und dieser Gegenstand bei der Versendung unmittelbar vom ersten Unternehmer an den letzten Abnehmer gelangt. Dieses Merkblatt unterst&uuml;tzt Sie bei der richtigen Beurteilung sowie der optimalen Gestaltung von Reihengesch&auml;ften und gibt Handlungsempfehlungen, um auch bei komplexen Lieferketten fehlerhafte Abrechnungen zu vermeiden.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=reihengeschaefte_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt181"></a><a class="merkblatt" href="javascript:toggleDiv('mb_181');">Reisekosten</a><div id="mb_181" class="mb_teaser" style="display:none;"><p class="mb_teaser">Wenn einer eine Dienstreise tut, dann hat er was zu erz&auml;hlen - unter anderem &uuml;ber die komplizierten Regelungen im Steuerrecht, wie Reisekosten steuermindernd geltend gemacht werden k&ouml;nnen. Dieses Merkblatt versetzt Sie in die Lage, diese M&ouml;glichkeiten optimal zu nutzen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=reisekosten_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt202"></a><a class="merkblatt" href="javascript:toggleDiv('mb_202');">Reverse-Charge&nbsp;&nbsp;<span class="update">[Update]</span></a><div id="mb_202" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die Umsatzsteuerpflicht macht bei einigen Ums&auml;tzen eine Kehrtwende, so dass Sie als Leistungsempf&auml;nger in diesem Fall der Steuerschuldner sind. Betroffen sind u.a. die Baubranche und Geb&auml;udereinigungsdienste, der Schrotthandel und der Handel mit bestimmten Metallen. Dieses Merkblatt erl&auml;utert das auf den ersten Blick komplizierte Verfahren.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=reverse_charge_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt182"></a><a class="merkblatt" href="javascript:toggleDiv('mb_182');">Scheinselbst&auml;ndigkeit</a><div id="mb_182" class="mb_teaser" style="display:none;"><p class="mb_teaser">Wenn Selbst&auml;ndige nur f&uuml;r einen Auftraggeber t&auml;tig sind, h&auml;ngt immer &uuml;ber beiden Vertragspartnern das Damoklesschwert der Scheinselbst&auml;ndigkeit. Gehen Sie auf Nummer sicher und informieren Sie sich &uuml;ber die steuer- und sozialversicherungsrechtlichen Folgen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=scheinselbstaendigkeit_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt290"></a><a class="merkblatt" href="javascript:toggleDiv('mb_290');">Sonderbetriebsausgaben bei Gesellschaftern</a><div id="mb_290" class="mb_teaser" style="display:none;"><p class="mb_teaser">Eine Personengesellschaft ist im Rahmen der Einkommen- oder K&ouml;rperschaftsteuer nicht steuerpflichtig, stattdessen werden die Ergebnisse auf Ebene der Gesellschafter besteuert. Wichtig sind hierbei die sogenannten Sonderbetriebsausgaben und -einnahmen, deren korrekte Erfassung die Ermittlung eines zutreffenden steuerlichen Ergebnisses f&uuml;r den einzelnen Gesellschafter gew&auml;hrleistet. In diesem Merkblatt erfahren Sie alles, was Sie zu diesem wichtigen Thema wissen m&uuml;ssen!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=sonderbetriebsausgaben_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt220"></a><a class="merkblatt" href="javascript:toggleDiv('mb_220');">Sozialversicherungen</a><div id="mb_220" class="mb_teaser" style="display:none;"><p class="mb_teaser">Welche Sozialversicherungen gibt es, was charakterisiert sie im Einzelnen, wer ist sozialversicherungspflichtig, wie lassen sich Beitr&auml;ge steuerlich geltend machen und wieso ist das ein wichtiges Thema f&uuml;r Arbeitnehmer ebenso wie f&uuml;r Unternehmer? Antworten gibt dieses Merkblatt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=sozialversicherungen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt219"></a><a class="merkblatt" href="javascript:toggleDiv('mb_219');">Steuerabzug nach &sect; 50a EStG</a><div id="mb_219" class="mb_teaser" style="display:none;"><p class="mb_teaser">In diesem Merkblatt wird erl&auml;utert, welche Eink&uuml;nfte &uuml;berhaupt vom Steuerabzug betroffen sind und wie der Steuerabzug durchgef&uuml;hrt wird - insbesondere aus Sicht des Unternehmers, der die Steuer abzuf&uuml;hren hat. Ebenso wird die wichtige Frage der Haftung gekl&auml;rt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=steuerabzug_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt184"></a><a class="merkblatt" href="javascript:toggleDiv('mb_184');">Taxigewerbe</a><div id="mb_184" class="mb_teaser" style="display:none;"><p class="mb_teaser">Durch den regen Bargeldverkehr und die zwingend vorgeschriebene Konzession sind im Taxigewerbe steuerlich viele Besonderheiten zu beachten. Setzen Sie sich mit diesem Merkblatt ins Bild, damit Sie steuerlich nicht die falsche Abzweigung nehmen!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=taxigewerbe_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt240"></a><a class="merkblatt" href="javascript:toggleDiv('mb_240');">Transparenzregister &amp; Geldw&auml;schepr&auml;vention</a><div id="mb_240" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die Bek&auml;mpfung von Geldw&auml;sche erlangt aufgrund stets komplexer werdenden Strukturen der organisierten Kriminalit&auml;t immer mehr Wichtigkeit. Hierzu gibt es in Deutschland umfangreiche Regelungen, die auch Unternehmen dazu verpflichten, bei ihren Kunden entsprechende Pr&uuml;fungen, etwa der Identit&auml;t, durchzuf&uuml;hren. Dieses Merkblatt informiert &uuml;ber die Pflichten, von denen kleine und mittelst&auml;ndische Unternehmen betroffen sein k&ouml;nnen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=transparenzregister_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt268"></a><a class="merkblatt" href="javascript:toggleDiv('mb_268');">Umsatzsteuer bei Aufsichtsr&auml;ten</a><div id="mb_268" class="mb_teaser" style="display:none;"><p class="mb_teaser">Sowohl Aufsichtsräte als auch beaufsichtigte Aktiengesellschaften sehen sich mit einem hohen Maß an Unsicherheit bezüglich der umsatzsteuerlichen Behandlung von Aufsichtsratshonoraren konfrontiert. Dieses Merkblatt erklärt die Hintergründe der Rechtsprechung sowie Verwaltungsauffassung und gibt Ihnen klare Handlungsempfehlungen.
<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=umsatzsteuer_aufsichtsraete_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt185"></a><a class="merkblatt" href="javascript:toggleDiv('mb_185');">Umsatzsteuer bei grenz&uuml;berschreitenden Dienstleistungen</a><div id="mb_185" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die korrekte Zuordnung der Umsatzsteuer gestaltet sich bei grenz&uuml;berschreitenden Dienstleistungen (innerhalb und au&szlig;erhalb der EU) immer wieder als schwieriges Unterfangen. Mit diesem Merkblatt schl&uuml;sseln wir Ihnen dieses komplexe Feld mit vielen Beispielen auf.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=umsatzsteuer_grenzueberschreitende_dl_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt186"></a><a class="merkblatt" href="javascript:toggleDiv('mb_186');">Umsatzsteuer und Gewerbesteuer bei Heilberufen</a><div id="mb_186" class="mb_teaser" style="display:none;"><p class="mb_teaser">Leistungen im Zusammenhang mit einer Krankheit durch Angeh&ouml;rige der heilenden Berufe sind umsatzsteuerfrei und als Freiberufler unterstehen Sie auch nicht der Gewerbesteuer, aber wie so h&auml;ufig existieren viele Ausnahmen. Mit diesem Merkblatt behalten Sie den &Uuml;berblick.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=umsatz_gewerbesteuer_bei_heilberufen_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt258"></a><a class="merkblatt" href="javascript:toggleDiv('mb_258');">Umsatzsteuererh&ouml;hung 2021</a><div id="mb_258" class="mb_teaser" style="display:none;"><p class="mb_teaser">Zum 01.01.2021 erh&ouml;hen sich die Steuers&auml;tze wieder auf 19 % bzw. 7 %. Was m&uuml;ssen Sie dabei beachten, welche Gestaltungsm&ouml;glichkeiten haben sie und wo k&ouml;nnten m&ouml;gliche Pr&uuml;fungsschwerpunkte der Finanz&auml;mter liegen? Die Antworten auf diese und weitere Fragen bietet dieses Merkblatt!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=umsatzsteuererhoehung_2021_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt247"></a><a class="merkblatt" href="javascript:toggleDiv('mb_247');">Umsatzsteuersenkung 2020</a><div id="mb_247" class="mb_teaser" style="display:none;"><p class="mb_teaser">Für die zweite Hälfte des Jahres 2020 wird die Umsatzsteuer gesenkt. Unser Merkblatt erklärt Ihnen, worauf Sie jetzt bei der Umsetzung dieser Änderung achten müssen!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=umsatzsteuersenkung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt188"></a><a class="merkblatt" href="javascript:toggleDiv('mb_188');">Umsatzsteuervoranmeldung</a><div id="mb_188" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die Umsatzsteuer ist ein Sonderfall der Steuern: Als Unternehmer m&uuml;ssen Sie die Umsatzsteuer in k&uuml;rzeren zeitlichen Abst&auml;nden selbst berechnen und an Ihr Finanzamt &uuml;bermitteln. Was Sie dabei beachten m&uuml;ssen und welche Regelungen bestehen, haben wir hier f&uuml;r Sie zusammengefasst.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=umsatzsteuervoranmeldung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt189"></a><a class="merkblatt" href="javascript:toggleDiv('mb_189');">Unterlagen f&uuml;r die Jahresbuchhaltung</a><div id="mb_189" class="mb_teaser" style="display:none;"><p class="mb_teaser">Damit Ihre Jahresbuchhaltung schnell und effizient durchgef&uuml;hrt werden kann, k&ouml;nnen Sie anhand dieser einfachen Checkliste selbst pr&uuml;fen, ob alle Unterlagen vorliegen. Eine kurze Checkliste der erforderlichen Rechnungsangaben ist ebenfalls integriert.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=jahresbuchhaltung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt190"></a><a class="merkblatt" href="javascript:toggleDiv('mb_190');">Unternehmensformen und Steuerbelastung im Vergleich</a><div id="mb_190" class="mb_teaser" style="display:none;"><p class="mb_teaser">Eine der wichtigsten Fragen f&uuml;r Unternehmer: Welche Unternehmensform ist die ideale? Die Vor- und Nachteile der einzelnen Unternehmensformen und ihre steuerlichen Auswirkungen werden hier f&uuml;r Sie anschaulich erkl&auml;rt.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=unternehmensformen_steuerbelastung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt191"></a><a class="merkblatt" href="javascript:toggleDiv('mb_191');">Verdeckte Gewinnaussch&uuml;ttung</a><div id="mb_191" class="mb_teaser" style="display:none;"><p class="mb_teaser">Wenn Leistungen ohne angemessene Gegenleistung von einer Kapitalgesellschaft an einen Gesellschafter erbracht werden, steht immer der Verdacht einer verdeckten Gewinnaussch&uuml;ttung im Raum &ndash; mit steuerlichen Konsequenzen. Hier erfahren Sie alles Wichtige zu dieser oftmals heiklen Materie.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=verdeckte_gewinnausschuettung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt224"></a><a class="merkblatt" href="javascript:toggleDiv('mb_224');">Verfahrensdokumentation</a><div id="mb_224" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die Verfahrensdokumentation als wichtiger Bestandteil der GoBD r&uuml;ckt immer st&auml;rker in den Fokus der Finanzbeh&ouml;rden. Bei Betriebspr&uuml;fungen reicht es nicht (mehr), auf die Schnelle noch etwas zusammenzustellen, sondern es gilt unbedingt, gut vorbereitet zu sein. Sonst drohen Sanktionen!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=verfahrensdokumentation_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt296"></a><a class="merkblatt" href="javascript:toggleDiv('mb_296');">Verrechnungspreisdokumentation</a><div id="mb_296" class="mb_teaser" style="display:none;"><p class="mb_teaser">Verrechnungspreise sind die Preise und Konditionen, die zwischen verbundenen Unternehmen eines internationalen Konzerns berechnet werden. Sie regeln die Gewinnverteilung zwischen den Gesellschaften in unterschiedlichen L&auml;ndern und m&uuml;ssen dem Grundsatz der Fremd&uuml;blichkeit entsprechen. Um die Fremd&uuml;blichkeit gegen&uuml;ber dem Finanzamt darzustellen, muss eine Verrechnungspreisdokumentation erstellt werden. In diesem Merkblatt erfahren Sie, was bei einer solchen Dokumentation zu beachten ist!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=verrechnungspreisdokumentation_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt286"></a><a class="merkblatt" href="javascript:toggleDiv('mb_286');">Vorratsbewertung</a><div id="mb_286" class="mb_teaser" style="display:none;"><p class="mb_teaser">Wie werden die Vorr&auml;te und halbfertigen Waren des Unternehmens in der Bilanz korrekt dargestellt? Dieses Merkblatt zeigt Ihren Mandanten auf, worauf sie hierbei achten m&uuml;ssen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=vorratsbewertung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt194"></a><a class="merkblatt" href="javascript:toggleDiv('mb_194');">Vorsteuerverg&uuml;tungsverfahren</a><div id="mb_194" class="mb_teaser" style="display:none;"><p class="mb_teaser">Haben Sie Umsatzsteuer an ein Unternehmen mit Sitz im Ausland gezahlt? Mit dem Vorsteuerverg&uuml;tungsverfahren k&ouml;nnen Sie sich diese, wie bei der inl&auml;ndischen Vorsteuer, wieder zur&uuml;ckholen. Erfahren Sie, wie Sie dabei vorgehen m&uuml;ssen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=vorsteuerverguetungsverfahren_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt195"></a><a class="merkblatt" href="javascript:toggleDiv('mb_195');">Wechsel der Gewinnermittlungsart</a><div id="mb_195" class="mb_teaser" style="display:none;"><p class="mb_teaser">Wurden Sie vom Finanzamt dazu aufgefordert, Ihren Gewinn k&uuml;nftig durch einen Bestandsvergleich zu ermitteln? Oder wollen Sie von der Bilanzierung zur Einnahmen&uuml;berschussrechnung wechseln? Dann erfahren Sie hier mehr zu den Punkten, welche Sie beachten sollten.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=wechsel_gewinnermittlungsart_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt248"></a><a class="merkblatt" href="javascript:toggleDiv('mb_248');">&Uuml;berbr&uuml;ckungshilfe f&uuml;r KMU (1. Phase)</a><div id="mb_248" class="mb_teaser" style="display:none;"><p class="mb_teaser">Zur Abmilderung der wirtschaftlichen Folgen des Lockdown im Frühjahr 2020 hat die Bundesregierung umfangreiche Überbrückungshilfen für kleine und mittelständische Unternehmen beschlossen. Erfahren Sie hier, wie Sie von dieser Finanzspritze profitieren können!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=ueberbrueckungshilfe_1_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt250"></a><a class="merkblatt" href="javascript:toggleDiv('mb_250');">&Uuml;berbr&uuml;ckungshilfe II &amp; November-/Dezemberhilfe</a><div id="mb_250" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die Überbrückungshilfe geht in die zweite Phase! Finden Sie hier alles, was Sie zu den Antragsvoraussetzungen und Fristen wissen müssen – inklusive einer praktischen Arbeitshilfe, damit Sie uns optimal bei der Antragstellung unterstützen können.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=ueberbrueckungshilfe_2_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt253"></a><a class="merkblatt" href="javascript:toggleDiv('mb_253');">&Uuml;berbr&uuml;ckungshilfe III &amp; Neustarthilfe</a><div id="mb_253" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die dritte Phase der Überbrückungshilfe bietet u.a. einen erweiterten Förderzeitraum und verbesserte Konditionen für Unternehmen, die direkt und indirekt durch den zweiten Total-Lockdown betroffen sind. Außerdem erhalten Sie in diesem Merkblatt alle wichtigen Informationen zur Neustarthilfe für Soloselbständige!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=ueberbrueckungshilfe_3_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt259"></a><a class="merkblatt" href="javascript:toggleDiv('mb_259');">&Uuml;berbr&uuml;ckungshilfe III Plus &amp; Neustarthilfe Plus</a><div id="mb_259" class="mb_teaser" style="display:none;"><p class="mb_teaser">Die Soforthilfen in der Pandemie gehen mit der &Uuml;berbr&uuml;ckungshilfe III Plus und erweiterten F&ouml;rderbedingungen in die n&auml;chste Phase. Hier finden Sie au&szlig;erdem alle wichtigen Informationen zur Neustarthilfe Plus!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=ueberbrueckungshilfe_3_plus_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt265"></a><a class="merkblatt" href="javascript:toggleDiv('mb_265');">&Uuml;berbr&uuml;ckungshilfe IV &amp; Neustarthilfe 2022</a><div id="mb_265" class="mb_teaser" style="display:none;"><p class="mb_teaser">Mit der &Uuml;berbr&uuml;ckungshilfe IV und der Neustarthilfe unterst&uuml;tzt die Regierung auch im Jahr 2022 Unternehmen, die unter der anhaltenden Pandemie leiden. Im Merkblatt finden Sie alle wichtigen Informationen zu diesen Corona-Hilfen!<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=ueberbrueckungshilfe_4_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li><li class="merkblattzeile"><a class="anker" name="merkblatt275"></a><a class="merkblatt" href="javascript:toggleDiv('mb_275');">&Uuml;berbr&uuml;ckungshilfe: Schlussabrechnung</a><div id="mb_275" class="mb_teaser" style="display:none;"><p class="mb_teaser">F&uuml;r die Corona-Hilfen der Jahre 2020 bis 2022 ist die Schlussabrechnung f&auml;llig. Dieses Merkblatt zeigt Ihnen, welche Unterlagen ben&ouml;tigt werden und wie sie ihren pr&uuml;fenden Dritten bei der Schlussabrechnung unterst&uuml;tzen k&ouml;nnen.<br/><div class="mb_link"><img class="download" src="https://www.deubner-online.de/commons/images/download.png">&nbsp;&nbsp;<a class="mmb_download" target="_blank" href="https://www.deubner-online.de/einbau/mmo/controllers/download.php?kdnr=001b000000sUyU4&merkblatt=schlussabrechnung_final&header=">Merkblatt herunterladen</a></div></p><hr></div></li></ul></div></div><div class="datenschutz"><a href="https://www.deubner-verlag.de/datenschutzerklaerung-homepageservice" target="_blank" rel="nofollow" onclick="FensterOeffnen(this.href, 640, 600); return false">Datenschutzhinweis</a><br><br></div></div>
</div>
<div id="txtHint"></div>
<!--MMB-Ende-->