"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>BTSP II FUNDO DE INVESTIMENTO IMOBILIÁRIO - FII</NomeFundo>
		<CNPJFundo>36930464000144</CNPJFundo>
		<DataFuncionamento>2021-06-01</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRBTSICTF001</CodigoISIN>
		<QtdCotasEmitidas>6373961</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<EnquadraNotaSeis>false</EnquadraNotaSeis>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Multiestratégia</Classificacao>
			<Subclassificacao>Não possui subclassificação</Subclassificacao>
			<SegmentoAtuacao>Outros</SegmentoAtuacao>
			<TipoGestao>Ativa</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>31/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>true</Bolsa>
			<MBO>false</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>true</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>INTER DISTRIBUIDORA DE TÍTULOS E VALORES MOBILIÁRIOS LTDA</NomeAdministrador>
		<CNPJAdministrador>36930464000144</CNPJAdministrador>
		<Logradouro>AV BARBACENA</Logradouro>
		<Numero>1219</Numero>
		<Complemento>21º ANDAR</Complemento>
		<Bairro>SANTO AGOSTINHO</Bairro>
		<Cidade>BELO HORIZONTE</Cidade>
		<Estado>MG</Estado>
		<CEP>30190131</CEP>
		<Telefone1>(31) 3614-5332</Telefone1>
		<Telefone2/>
		<Telefone3 xsi:nil="true"/>
		<Site>http://www.bancointer.com.br/inter-dtvm</Site>
		<Email>ri.fii@interdtvm.com.br</Email>
		<Competencia>01/2026</Competencia>
		<DataEncerTrimestre>2026-03-31</DataEncerTrimestre>
	</DadosGerais>
	<InformeTrimestral>
		<InfoTipoAtivo>
			<DireitosReaisImoveis>
				<Terrenos>
				</Terrenos>
				<Imoveis>
					<ImoveisRendaAcabados>
						<LstImovRendaAcabados>
							<Imovel>
								<Nome>Condomínio Logístico Itapeva 01</Nome>
								<Endereco>Estrada Municipal de Areias, N.º 1.000, Bairro Mandu, Itapeva, Minas Gerais.</Endereco>
								<Area>59348.88</Area>
								<NumUnidades>2</NumUnidades>
								<OutrasCaractRelevantes>Fração do imóvel onde estão edificados os galpões 1A e 1B, dos quais o BTSP II FUNDO DE INVESTIMENTO IMOBILIÁRIO – FII detem 41,6123%. Imóvel objeto da matrícula N.º 18.051 do Livro 02, registrada perante o Cartório de Registro de Imóveis da Comarca de Camanducaia, Minas Gerais.</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.108743</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>E-Commerce</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.108743</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Condomínio Logístico Cariacica 01</Nome>
								<Endereco>Rua África do Sul, N.º 2.280, Bairro Padre Mathias, Cariacica, Espírito Santo.</Endereco>
								<Area>113559.76</Area>
								<NumUnidades>7</NumUnidades>
								<OutrasCaractRelevantes>Fração do Imóvel onde estão edificados os galpões 1A, 1B, 1C, 2 e 3, dos quais o BTSP II FUNDO DE INVESTIMENTO IMOBILIÁRIO – FII detem 46,01%. Imóvel objeto das matrículas N.º 9.019, 9.020, 9.021, 9.022 e 9.023 registradas perante o Cartório de Registro de Imóveis da Comarca de Cariacica, Espírito Santo.</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.235503</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Varejo</SetorAtuacao><PercentReceitaImovel>0.59555</PercentReceitaImovel><PercentReceitasFII>0.140254</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Eletrodomésticos</SetorAtuacao><PercentReceitaImovel>0.217354</PercentReceitaImovel><PercentReceitasFII>0.051188</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Celulose</SetorAtuacao><PercentReceitaImovel>0.088051</PercentReceitaImovel><PercentReceitasFII>0.020736</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Logística</SetorAtuacao><PercentReceitaImovel>0.099044</PercentReceitaImovel><PercentReceitasFII>0.023325</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Condomínio Logístico Cravinhos 01</Nome>
								<Endereco>Avenida Roberto Gusmão, N.º 1.000, Bairro Distrito Industrial, Cravinhos, São Paulo.</Endereco>
								<Area>25818.28</Area>
								<NumUnidades>2</NumUnidades>
								<OutrasCaractRelevantes>Fração do imóvel onde estão edificados os galpões  1A e 1B dos quais o BTSP II FUNDO DE INVESTIMENTO IMOBILIÁRIO – FII detem 79,40445%. Imóvel designado por “Fazenda Jandaia”, objeto da matrícula nº 24.246 do Livro n° 2 do Ofício de Registro de Imóveis da Comarca de Cravinhos, São Paulo.</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.097246</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>E-Commerce</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.097246</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Condomínio Logístico Sumaré 01</Nome>
								<Endereco>Rodovia Adauto Campo Dall’Orto, N.º 2.000, Bairro Nova Veneza, Sumaré, São Paulo.</Endereco>
								<Area>73256.74</Area>
								<NumUnidades>2</NumUnidades>
								<OutrasCaractRelevantes>Fração do Imóvel onde estão edificados os galpões 1A e 1B, dos quais o BTSP II FUNDO DE INVESTIMENTO IMOBILIÁRIO – FII detem 78,1198%. Imóvel objeto das matrículas N.º 210.352 do Livro n° 2 do Oficial de Registro de Imóveis, Títulos e Documentos e Civil de Pessoa Jurídica de Sumaré/SP.</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.27843</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>E-Commerce</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.27843</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Condomínio Logístico Marília 01</Nome>
								<Endereco>Avenida Eugênio Coneglian, N.º 3550, Bairro Distrito Industrial, Marília, São Paulo.</Endereco>
								<Area>63101.01</Area>
								<NumUnidades>3</NumUnidades>
								<OutrasCaractRelevantes>Fração do Imóvel onde serão edificados os galpões 1A ,1B e 1C, dos quais o BTSP II FUNDO DE INVESTIMENTO IMOBILIÁRIO – FII deterá 90,0684%. Imóvel objeto das matrículas N.º 75.993 do Livro n° 2 do Oficial de Registro de Imóveis da Comarca de Marília/SP.</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.280078</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>E-Commerce</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.280078</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
						</LstImovRendaAcabados>
						<DistrContratosPrazo>
							<AteTresMeses>Até 3 meses</AteTresMeses>
							<TresAteSeisMeses>De 3 meses e 1 dia a 6 meses</TresAteSeisMeses>
							<SeisAteNoveMeses>De 6 meses e 1 dia a 9 meses</SeisAteNoveMeses>
							<NoveAteDozeMeses>De 9 meses e 1 dia a 12 meses</NoveAteDozeMeses>
							<DozeAteQuinzeMeses>De 12 meses e 1 dia a 15 meses</DozeAteQuinzeMeses>
							<QuinzeAteDezoitoMeses>De 15 meses e 1 dia a 18 meses</QuinzeAteDezoitoMeses>
							<DezoitoAteVinteUmMeses percentReceitaImovel="0.051188" percentReceitasFII="0.051188">De 18 meses e 1 dia a 21 meses</DezoitoAteVinteUmMeses>
							<VinteUmAteVinteQuatroMeses>De 21 meses e 1 dia a 24 meses</VinteUmAteVinteQuatroMeses>
							<VinteQuatroAteVinteSeteMeses>De 24 meses e 1 dia a 27 meses</VinteQuatroAteVinteSeteMeses>
							<VinteSeteAteTrintaMeses>De 27 meses e 1 dia a 30 meses</VinteSeteAteTrintaMeses>
							<TrintaAteTrintaTresMeses>De 30 meses e 1 dia a 33 meses</TrintaAteTrintaTresMeses>
							<TrintaTresAteTrintaSeisMeses>De 33 meses e 1 dia a 36 meses</TrintaTresAteTrintaSeisMeses>
							<AcimaTrintaSeisMeses percentReceitaImovel="0.948812" percentReceitasFII="0.948812">Acima de 36 meses</AcimaTrintaSeisMeses>
							<PrazoIndeterminado>Prazo indeterminado</PrazoIndeterminado>
						</DistrContratosPrazo>
						<DistrContratosIndexador>
							<IGPM/>
							<INPC/>
							<IPCA percentReceitaImovel="1" percentReceitasFII="1"/>
							<INCC/>
							<OutrosIndicadores>
							</OutrosIndicadores>
						</DistrContratosIndexador>
						<CaractContratuaisComuns>Contratos típicos que seguem a lei do inquilinato, com reajuste anual por índice, aviso prévio e multa por rescisão antecipada bem como contratos atípicos de locação.</CaractContratuaisComuns>
						<CaractContratuaisIndividual>
							<Imovel>
								<NomeOuEndereco>N/A</NomeOuEndereco>
								<CaractContratuais>N/A</CaractContratuais>
							</Imovel>
						</CaractContratuaisIndividual>
						<PoliticaContratacaoSeguro>A contratação e manutenção dos seguros para preservação dos imóveis é uma responsabilidade contratual dos inquilinos durante todo o período de contrato. É feito o gerenciamento das vigências das apólices de seguros e, para a cotação dos valores em risco do imóvel é considerado o custo de reposição indicado no laudo de avaliação feito por empresa independente ou alguma base técnica normativa de referência como CUB ou SINAPI, além de uma análise de risco para fins de cobertura.</PoliticaContratacaoSeguro>
					</ImoveisRendaAcabados>
					<ImoveisRendaConstrucao>
						<LstImovRendaConstrucao>
						</LstImovRendaConstrucao>
						<JustificativaDesempenho>
						</JustificativaDesempenho>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisRendaConstrucao>
					<ImoveisVendaAcabados>
						<LstImovVendaAcabados>
						</LstImovVendaAcabados>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisVendaAcabados>
					<ImoveisVendaConstrucao>
						<LstImovVendaConstrucao>
						</LstImovVendaConstrucao>
						<JustificativaDesempenho>
						</JustificativaDesempenho>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisVendaConstrucao>
				</Imoveis>
				<OutrosDireitosReais>
				</OutrosDireitosReais>
			</DireitosReaisImoveis>
			<AtivosFinanceiros>
				<FII>
				</FII>
				<CriCra>
				</CriCra>
				<LciLca>
				</LciLca>
				<LIG>
				</LIG>
				<CEPAC>
				</CEPAC>
				<Acoes>
				</Acoes>
				<AcoesSocFII>
				</AcoesSocFII>
				<CotasSocFII>
				</CotasSocFII>
				<FIA>
				</FIA>
				<FIP>
				</FIP>
				<FIDC>
				</FIDC>
				<OutrasCotasFI>
				</OutrasCotasFI>
				<OutrosAtivosFinanceiros>
				</OutrosAtivosFinanceiros>
			</AtivosFinanceiros>
			<AtivosNecessidadeLiquidez>
				<Disponibilidades>579683.76</Disponibilidades>
				<TitulosPublicos xsi:nil="true"/>
				<TitulosPrivados xsi:nil="true"/>
				<FundosRendaFixa xsi:nil="true"/>
			</AtivosNecessidadeLiquidez>
		</InfoTipoAtivo>
		<AquisicoesAlienacoes>
			<Terrenos>
				<Aquisicoes>
				</Aquisicoes>
				<Alienacoes>
				</Alienacoes>
			</Terrenos>
			<Imoveis>
				<Aquisicoes>
				</Aquisicoes>
				<Alienacoes>
				</Alienacoes>
			</Imoveis>
		</AquisicoesAlienacoes>
		<OutrasInfo>
			<RentabilidadeGarantida>
				<AtivosGarantiaRent>
				</AtivosGarantiaRent>
				<RentEfetivaVigGarantia>
				</RentEfetivaVigGarantia>
			</RentabilidadeGarantida>
		</OutrasInfo>
		<DemonstracoesContabilFinanc>
			<AtivosImobiliarios>
				<Estoques>
					<ReceitasVenda/>
					<CustoImovEstoque/>
					<AjusteValor/>
					<OutrasRecOuDesp/>
					<ResultadoLiquido contabil="0" financeiro="0"/>
				</Estoques>
				<PropriedadesInvest>
					<ReceitasAlugueis contabil="16039618.2" financeiro="15464085.24"/>
					<DespManutencaoConservacao/>
					<ReceitasVenda/>
					<CustoPropriedadesVendidas/>
					<AjusteValor/>
					<OutrasRecOuDesp contabil="-450.39"/>
					<ResultadoLiquido contabil="16039167.81" financeiro="15464085.24"/>
				</PropriedadesInvest>
				<TVM>
					<ReceitasJuros/>
					<AjusteValor/>
					<ResultadoVenda/>
					<OutrasRecOuDesp/>
					<ResultadoLiquido contabil="0" financeiro="0"/>
				</TVM>
				<ResultadoLiquidoTotal contabil="16039167.81" financeiro="15464085.24"/>
			</AtivosImobiliarios>
			<RecursosLiquidez>
				<ReceitasJurosAplicacoes/>
				<AjusteValorAplicacoes/>
				<ResultadoVendaAplicacoes/>
				<OutrasRecOuDespAplicacoes/>
				<ResultadoLiquido contabil="0" financeiro="0"/>
			</RecursosLiquidez>
			<ResultadoLiquidoDerivativos/>
			<OutrasReceitasDespesas>
				<TaxaAdministracao contabil="-470576.35" financeiro="-260336.33"/>
				<TaxaDesempenho/>
				<ConsultoriaEspecializada contabil="-296284" financeiro="-450000"/>
				<EmpresaEspecializada/>
				<FormadorMercado/>
				<CustodiaTitulosValores/>
				<AuditoriaIndependente contabil="-26601.22" financeiro="-69845"/>
				<RepresentantesCotistas/>
				<TaxasImpostosContribuicoes contabil="-10962.64" financeiro="-10962.64"/>
				<ComissoesEmolumentos contabil="-3881.28"/>
				<HonorariosDespesasDefesas/>
				<GastosContratosSeguros/>
				<DespesasAvaliacoes contabil="-10933.03" financeiro="-18066"/>
				<TaxasIngressoSaidaFundos/>
				<DespesasRegistroCartorio financeiro="-450.39"/>
				<OutrasRecOuDesp contabil="-1372.7" financeiro="-4917.28"/>
				<Total contabil="-820611.22" financeiro="-814577.64"/>
			</OutrasReceitasDespesas>
			<ResultadoTrimestralLiquido contabil="15218556.59" financeiro="14649507.6"/>
		</DemonstracoesContabilFinanc>
		<DistrResultadoAcumulado>
			<ResultadoFinanLiqAcumulado>14649507.6</ResultadoFinanLiqAcumulado>
			<PercentResultFinanLiqAcumulado>13917032.22</PercentResultFinanLiqAcumulado>
			<ParcelaDistribuidaTriSeguinte xsi:nil="true"/>
			<ParcelasRendimentosRetidos>
			</ParcelasRendimentosRetidos>
			<LucroContabil xsi:nil="true"/>
			<ResultadoFinanceiroExcedeMinimo>662174.39</ResultadoFinanceiroExcedeMinimo>
			<RendimentosDeclarados>14579206.61</RendimentosDeclarados>
			<RendimentosPagosAntec>-9288818.98</RendimentosPagosAntec>
			<RendimentoPagar>5290387.63</RendimentoPagar>
			<ResultadoLiquidoDeclarado>0.995201</ResultadoLiquidoDeclarado>
		</DistrResultadoAcumulado>
	</InformeTrimestral>
</DadosEconomicoFinanceiros>
"