"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<InformeMensalCRI xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<Competencia>2021-06-01</Competencia>
		<Emissao>
			<NumeroEmissao>1</NumeroEmissao>
			<CodigoIdentificacao>BRRBRACRI1K0</CodigoIdentificacao>
			<QuantidadeSeries>1</QuantidadeSeries>
			<DataEmissao>2010-02-01</DataEmissao>
		</Emissao>
		<CompanhiaEmissora>RB Capital Companhia de Securitização</CompanhiaEmissora>
		<CNPJCompanhia>02773542000122</CNPJCompanhia>
		<InstituicaoRegimeFiduciario>Sim</InstituicaoRegimeFiduciario>
		<AgenteFiduciario>Pentágono DTVM</AgenteFiduciario>
		<CNPJAgenteFiduciario>17343682000138</CNPJAgenteFiduciario>
		<Custodiante>Pentágono DTVM</Custodiante>
		<CNPJCustodiante>17343682000138</CNPJCustodiante>
		<SegmentoCreditosVinculados>Imobiliário - Residencial</SegmentoCreditosVinculados>
		<OutroSegmentoCreditosVinculados/>
		<ValorAquisicaoCredito>25352973.893131</ValorAquisicaoCredito>
		<TaxasIndexadoresCreditosVinculados>TR + 7,413% a.a.</TaxasIndexadoresCreditosVinculados>
		<AnosDurationCarteira>5</AnosDurationCarteira>
		<MesesDurationCarteira>7</MesesDurationCarteira>
		<FormaCalculoDuration>Somatório do valor presente das parcelas, pela taxa efetiva pela qual o CRI foi emitido, ponderadas pelo prazo entre a data de vencimento de cada parcela e a data de cálculo; dividido pelo saldo devedor dos créditos, na data base de cálculo</FormaCalculoDuration>
		<TiposGarantiasCoobrigacaoSecuritizadora>Não aplicável, a emissão não conta com garantias ou coobrigação prestadas pela companhia securitizadora.</TiposGarantiasCoobrigacaoSecuritizadora>
		<TiposGarantiasCoobrigacaoTerceiros>(i) Regime Fiduciário [100%], (ii) Patrimônio Separado [100%]</TiposGarantiasCoobrigacaoTerceiros>
		<DataLTV>2021-06-30</DataLTV>
		<IndiceLTV>0.999</IndiceLTV>
		<DevedorMais20Porcento1>0</DevedorMais20Porcento1>
		<DevedorMais20Porcento2>0</DevedorMais20Porcento2>
		<DevedorMais20Porcento3>0</DevedorMais20Porcento3>
		<DevedorMais20Porcento4>0</DevedorMais20Porcento4>
		<DevedorMais20Porcento5>0</DevedorMais20Porcento5>
		<Series>
			<Serie>
				<Classe>Sênior</Classe>
				<NumeroSerie>62</NumeroSerie>
				<CodigoNegociacaoMercadoSec>10B0002537</CodigoNegociacaoMercadoSec>
				<CodigoISIN>BRRBRACRI1K0</CodigoISIN>
				<Quantidade>1</Quantidade>
				<Valor>25352973.893131</Valor>
				<DataVencimento>2027-01-01</DataVencimento>
				<TaxasIndexadores>TR + 7,413% a.a.</TaxasIndexadores>
				<ClassificacaoRiscoAtual/>
				<NivelSubordinacao xsi:nil="true"/>
				<PeriodicidadeAmortizacao>só no vencimento</PeriodicidadeAmortizacao>
			</Serie>
		</Series>
		<ClassificacaoRisco>
			<AgenciaClassificadora/>
			<CNPJAgenciaClassificadora/>
			<DataUltimaClassificacao xsi:nil="true"/>
		</ClassificacaoRisco>
	</DadosGerais>
	<InformacoesFinanceiras>
		<Ativo total="61809417">
			<AtivoCirculante total="0">
				<Disponibilidades>0</Disponibilidades>
				<AplicacoesTitulosValoresMobiliarios>0</AplicacoesTitulosValoresMobiliarios>
				<CreditosVinculados>0</CreditosVinculados>
				<OutrosAtivos>0</OutrosAtivos>
			</AtivoCirculante>
			<AtivoNaoCirculante total="61809417">
				<AplicacoesTitulosValoresMobiliarios>0</AplicacoesTitulosValoresMobiliarios>
				<CreditosVinculados>61809417</CreditosVinculados>
				<OutrosAtivos>0</OutrosAtivos>
			</AtivoNaoCirculante>
		</Ativo>
		<Passivo total="61809417">
			<PassivoCirculante total="0">
				<ValoresMobiliariosEmitidos>0</ValoresMobiliariosEmitidos>
				<OutrosPassivos>0</OutrosPassivos>
			</PassivoCirculante>
			<PassivoNaoCirculante total="61809417">
				<ValoresMobiliariosEmitidos>61809417</ValoresMobiliariosEmitidos>
				<OutrosPassivos>0</OutrosPassivos>
			</PassivoNaoCirculante>
		</Passivo>
		<MovimentacaoFinanceira>
			<TotalRecebimentos>0</TotalRecebimentos>
			<PgtosDespesasComissoesSecuritizacao>0</PgtosDespesasComissoesSecuritizacao>
			<PgtosClasseSenior total="0">
				<AmortizacaoPrincipal>0</AmortizacaoPrincipal>
				<Juros>0</Juros>
			</PgtosClasseSenior>
			<PgtosClasseSubordinada total="0">
				<AmortizacaoPrincipal>0</AmortizacaoPrincipal>
				<Juros>0</Juros>
			</PgtosClasseSubordinada>
			<OutrosPagamentosRecebimentos>0</OutrosPagamentosRecebimentos>
			<SuficienciaInsuficienciaCaixa>0</SuficienciaInsuficienciaCaixa>
			<PremioSubordinacao>0</PremioSubordinacao>
			<ValorSecuritizadora>0</ValorSecuritizadora>
			<ValorFundoDespesa>0</ValorFundoDespesa>
			<ValorFundosReforcoCreditoLiquidez>0</ValorFundosReforcoCreditoLiquidez>
			<Outros>
				<DescricaoOutrosValores>0</DescricaoOutrosValores>
				<OutrosValores>0</OutrosValores>
			</Outros>
			<ValoresPgtosContratuais total="0">
				<ClasseSenior>0</ClasseSenior>
				<ClasseSubordinada>0</ClasseSubordinada>
			</ValoresPgtosContratuais>
		</MovimentacaoFinanceira>
	</InformacoesFinanceiras>
	<ComportamentoCarteiraCreditosVinculados>
		<CreditosVinculados>
			<PorPrazoVencimento total="61809416.64">
				<Ate30Dias>0</Ate30Dias>
				<De31a60Dias>0</De31a60Dias>
				<De61a90Dias>0</De61a90Dias>
				<De91a120Dias>0</De91a120Dias>
				<De121a150Dias>0</De121a150Dias>
				<De151a180Dias>0</De151a180Dias>
				<AcimaDe180Dias>61809416.6421203</AcimaDe180Dias>
			</PorPrazoVencimento>
			<Inadimplentes total="0">
				<VencidosNaoPagosAte30Dias>0</VencidosNaoPagosAte30Dias>
				<VencidosNaoPagosDe31a60Dias>0</VencidosNaoPagosDe31a60Dias>
				<VencidosNaoPagosDe61a90Dias>0</VencidosNaoPagosDe61a90Dias>
				<VencidosNaoPagosDe91a120Dias>0</VencidosNaoPagosDe91a120Dias>
				<VencidosNaoPagosDe121a150Dias>0</VencidosNaoPagosDe121a150Dias>
				<VencidosNaoPagosDe151a180Dias>0</VencidosNaoPagosDe151a180Dias>
				<VencidosNaoPagosAcimaDe180Dias>0</VencidosNaoPagosAcimaDe180Dias>
			</Inadimplentes>
			<PagosAntecipadamente total="0">
				<PagosAte30DiasVencimento>0</PagosAte30DiasVencimento>
				<PagosEntre31a60DiasVencimento>0</PagosEntre31a60DiasVencimento>
				<PagosEntre61a90DiasVencimento>0</PagosEntre61a90DiasVencimento>
				<PagosEntre91a120DiasVencimento>0</PagosEntre91a120DiasVencimento>
				<PagosEntre121a150DiasVencimento>0</PagosEntre121a150DiasVencimento>
				<PagosEntre151a180DiasVencimento>0</PagosEntre151a180DiasVencimento>
				<PagosAntes180DiasVencimento>0</PagosAntes180DiasVencimento>
			</PagosAntecipadamente>
		</CreditosVinculados>
		<ModificacaoCarteiraMes>
			<Eventos>
				<Evento>
					<Descricao>Aquisições</Descricao>
					<Valor>0</Valor>
					<Justificativa xsi:nil="true"/>
				</Evento>
				<Evento>
					<Descricao>Alienações</Descricao>
					<Valor>0</Valor>
					<Justificativa xsi:nil="true"/>
				</Evento>
				<Evento>
					<Descricao>Retrocessões</Descricao>
					<Valor>0</Valor>
					<Justificativa xsi:nil="true"/>
				</Evento>
				<Evento>
					<Descricao>Substituições</Descricao>
					<Valor>0</Valor>
					<Justificativa xsi:nil="true"/>
				</Evento>
				<Evento>
					<Descricao>Recompras</Descricao>
					<Valor>0</Valor>
					<Justificativa xsi:nil="true"/>
				</Evento>
			</Eventos>
		</ModificacaoCarteiraMes>
		<InfoCreditosProcessoLiquidacao>Nao existem creditos em processo de liquidacao no mes.</InfoCreditosProcessoLiquidacao>
	</ComportamentoCarteiraCreditosVinculados>
	<EventosAmortAntecipadaFluxoPagtosMes>
		<ImpactoPrePgtoFluxoCaixa>Não ocorreram eventos de pré-pagamento da carteira de créditos.</ImpactoPrePgtoFluxoCaixa>
		<AnaliseImpactoPrePgtoParaDetentores>Não ocorreram eventos de pré-pagamento no fluxo previsto da operação .</AnaliseImpactoPrePgtoParaDetentores>
		<AnaliseImpactoEventosAcarretamAmortizacao>Não aplicável, não ocorreram outros eventos que pudessem acarretar amortização antecipada dos valores mobiliários.</AnaliseImpactoEventosAcarretamAmortizacao>
		<AnaliseImpactoFatosAfetaramFluxosPgtos>Não aplicável, não ocorreram outros eventos que pudessem acarretar amortização antecipada dos valores mobiliários.</AnaliseImpactoFatosAfetaramFluxosPgtos>
	</EventosAmortAntecipadaFluxoPagtosMes>
	<ResponsaveisConteudoInforme>
		<Responsavel>
			<Nome>Flavia Palacios Mendonça Bailune</Nome>
			<Cargo>Diretor de Relações com Investidores</Cargo>
		</Responsavel>
	</ResponsaveisConteudoInforme>
</InformeMensalCRI>
"