← Back to blog

Published on

Render or Railway for a small API in production: which one should you choose?

For a small API in production, Render is the more predictable choice: the 512 MB instance with the smallest paid Postgres costs US$ 13 a month, or R$ 74.20 on a Brazilian card with the 11/09/2026 PTAX rate (R$ 5.5146) and the 3.5% IOF. Railway charges by usage, at US$ 10 per GB of memory and US$ 20 per vCPU per month, and comes out cheaper when the API sits idle much of the time: in our example, with 1 GB of memory across the API and the database, the bill is US$ 12.65 (R$ 72.20), but it changes every month with traffic. Neither has a region in South America, so the API answers Brazilian users from the United States. If your audience is in Brazil, a platform in São Paulo solves both issues: on Zenifra, for example, the same API with PostgreSQL costs R$ 42.00 a month, in reais. This guide compares price, billing model, deploys, backups, free plans, and latency, with the source and date of every number.

Render or Railway: which one should you pick for a small API in production?

Pick Render if you want to know what you will pay before the month starts, and Railway if the API has low, irregular traffic and you are fine with a bill that follows consumption. On Render, each service has a fixed monthly price: the 512 MB Starter instance costs US$ 7 and the smallest paid Postgres, with 256 MB, costs US$ 6, for US$ 13 on the Hobby workspace, which has no monthly fee. On Railway, the Hobby subscription costs US$ 5 and turns into usage credit, and on top of it comes whatever memory, CPU, disk, and traffic the API and the database consume.

Both handle the basics of a production API well: deploys from GitHub or a Dockerfile, automatic HTTPS, environment variables, managed PostgreSQL with backups, and a dashboard with logs. The difference is less about the feature list and more about three practical decisions: how you prefer to pay, where your users are, and what happens to the bill when traffic doubles from one month to the next.

One point weighs on anyone in Brazil and applies to both. Render and Railway have no region in South America, and the closest region for both is in Virginia, in the United States. The bill also comes in dollars, on a card, with the daily exchange rate and the 3.5% IOF on international purchases. If your API serves Brazilian users, those two things belong in the comparison as much as the list price.

The prices in this guide were read from Render’s official pages and Railway’s documentation on 11/10/2026. The conversion uses the 11/09/2026 PTAX selling rate, published by Banco Central do Brasil, of R$ 5.5146 per dollar, plus the 3.5% IOF on international card purchases. Zenifra prices come from the public plans API, checked on the same day.

How much does a small API cost on Render and on Railway?

With a 512 MB API that is always on and a small PostgreSQL, the monthly bill is US$ 13 on Render and around US$ 12.65 on Railway, with the usage example described below. In reais, with PTAX and IOF, that is R$ 74.20 and R$ 72.20. As a reference, the table includes Zenifra, which runs the API and the database in São Paulo and bills in reais.

The usage example is the same for all three columns: the API uses about 0.5 GB of memory, the database another 0.5 GB, combined average CPU is 0.1 vCPU, the database stores 1 GB of data, and the API sends 10 GB of traffic a month. That is the profile of an internal API, the backend of an app with a few hundred active users, or an MVP that already has its first customers.

ItemRender (Hobby workspace)Railway (Hobby plan)Zenifra
ApplicationStarter, 0.5 CPU and 512 MB, US$ 7.000.5 GB of memory at US$ 10 per GB, US$ 5.00Basic, 0.5 vCPU and 512 MB, R$ 29.90
PostgreSQL0.1c-256mb, US$ 6.000.5 GB of memory, US$ 5.00DB-Starter, 0.3 vCPU and 256 MB, R$ 11.90
CPUIncluded in the instance0.1 vCPU average at US$ 20 per vCPU, US$ 2.00Included in the plan
Database disk (1 GB)US$ 0.30US$ 0.15 of volumeR$ 0.20
Egress (10 GB)5 GB included, plus 5 GB at US$ 0.15, US$ 0.7510 GB at US$ 0.05, US$ 0.50Not listed in the public price catalog
SubscriptionHobby workspace, US$ 0.00US$ 5.00, which becomes usage creditNone
Monthly totalUS$ 14.05US$ 12.65R$ 42.00
In reais, with PTAX and 3.5% IOFR$ 80.19R$ 72.20R$ 42.00, no IOF

Without disk and traffic, Render stays at the US$ 13 for the instance and the database, which becomes R$ 74.20. On Railway, the number in the table is an estimate: the platform measures the memory and CPU actually used, minute by minute, so an API that sits idle overnight pays less, and one that gets a traffic spike pays more. The US$ 5 Hobby subscription works as credit, and the bill only goes above it when usage goes above US$ 5.

On Zenifra, the same pair costs R$ 42.00 in reais: R$ 29.90 for Basic, R$ 11.90 for DB-Starter, and R$ 0.20 for the GB of PostgreSQL disk. The amount does not change with the exchange rate or with CPU usage, because CPU is included in the plan.

Fixed price or usage-based billing: which one is cheaper?

It depends on how much your API actually consumes. Render charges for the whole instance, busy or idle, and the upside is predictability: next month’s price is this month’s price. Railway charges for what the app uses, and the upside shows up when usage is low. When consumption goes up, the Railway bill goes up with it, and it can pass Render’s.

Railway’s formula is public. Memory costs US$ 10 per GB per month, CPU US$ 20 per vCPU per month, volumes US$ 0.15 per GB per month, and egress US$ 0.05 per GB. On Hobby, the first US$ 5 of usage is included in the subscription; on Pro, the first US$ 20. The documentation gives the example: with US$ 3 of usage on Hobby, the bill is US$ 5; with US$ 7 of usage, it is US$ 7.

The table below applies that formula to three profiles of the same API, keeping 1 GB of volume and 10 GB of traffic, and puts Render’s fixed price for the same size next to it.

Monthly usage profileMemory (API + database)Average CPURailway HobbyRender HobbyRailway in reais, with PTAX and IOF
API almost idle0.25 GB + 0.25 GB0.05 vCPUUS$ 6.65US$ 14.05R$ 37.96
This guide’s example0.5 GB + 0.5 GB0.1 vCPUUS$ 12.65US$ 14.05R$ 72.20
API busy all month1 GB + 1 GB0.5 vCPUUS$ 30.65US$ 14.05, if 512 MB is enoughR$ 174.94

The last profile shows why the comparison needs care. On Render, US$ 14.05 holds as long as the API fits in 512 MB and the database in 256 MB. If the API needs 1 GB, Render’s next step is the 2 GB instance, at US$ 25, and the 1 GB Postgres costs US$ 19. Railway has no steps: extra memory enters the bill the minute it is used.

To limit the risk of a large bill, Railway’s documentation has a cost control page and an answer on how to avoid spending more than planned. There is also the Serverless option, which puts the service to sleep 5 to 10 minutes after its last outbound traffic and wakes it on the next request. It lowers the cost of a lightly used API, but the first request after the pause waits for the service to start.

On Zenifra, the model is a fixed price in reais: CPU and memory are included in the plan, and billing can be hourly, monthly, or yearly. For a test environment that only runs during business hours, hourly billing is cheaper. For a production API that runs all month, the monthly plan pays off.

What happens when the team grows and more people need to deploy?

Then the workspace subscription enters the bill. On Render, the Hobby workspace has 1 seat, and adding more people to the same workspace takes Pro, at US$ 25 a month plus the price of each service. Pro also unlocks horizontal autoscaling, full-stack preview environments, 25 GB of included bandwidth, and a 7-day Postgres recovery window, against 3 days on Hobby.

On Railway, adding members to the workspace is a Pro feature, at US$ 20 a month, and those US$ 20 also become usage credit. For our example API, which uses US$ 12.65, the Pro bill stays at the US$ 20 subscription, because usage does not go past the included credit. Pro is also the plan Railway itself points to for teams shipping to production.

PlatformPlan for a teamSubscriptionExample APITotal in dollarsIn reais, with PTAX and 3.5% IOF
RenderPro workspaceUS$ 25.00US$ 13.30 (instance, database, and 1 GB of disk; traffic within the 25 GB)US$ 38.30R$ 218.60
RailwayProUS$ 20.00, which becomes usage creditUS$ 12.65, covered by the creditUS$ 20.00R$ 114.15
ZenifraOrganization with membersNoneR$ 42.00 (Basic, DB-Starter, and 1 GB)Not applicableR$ 42.00, no IOF

For a team, Railway comes out cheaper than Render at this size, because Render adds the US$ 25 subscription to the price of the services, while Railway turns the subscription into credit. Railway’s advantage shrinks once usage goes past the included US$ 20, and Render’s shows up when the team values paying the same amount every month.

On Zenifra, the price comes from the project and database plans, and the public catalog has no charge per organization member.

What changes in production: deploys, health checks, scaling, and backups?

Day to day, the two platforms are more alike than their prices suggest. Both deploy from a repository or a Dockerfile, deploy on every push, issue HTTPS certificates, and keep environment variables out of the code. The differences show up in the details that matter once the API has users: how the platform decides a deploy worked, how the app scales, and how long database backups are kept.

On Railway, the health check is for deploys: the platform calls the configured route until it gets a 2xx response and only then moves traffic to the new version, with a default timeout of 300 seconds. The documentation notes that Railway does not monitor that route after the deploy goes live. On Render, health checks and zero-downtime deploys are available on every workspace, and horizontal autoscaling starts on Pro.

FeatureRenderRailwayZenifra
Pricing modelFixed price per instance, plus the workspaceSubscription that becomes credit, plus metered usageFixed price per plan, in reais, hourly, monthly, or yearly
Region closest to BrazilVirginia (USA)US East, in Virginia (USA)São Paulo
DeploysGit and Docker, with automatic deploysGitHub and Dockerfile, with automatic deploysGitHub, Forgejo, or a Docker image
Health checkOn every workspaceOnly during deploys, with a 300 s default timeoutFrom Premium up, every 60 s, with a 5 s timeout
Horizontal scalingAutoscaling from the Pro workspace upReplicas: up to 6 on Hobby and 42 on ProAutoscaling available from the Static plan up
Postgres backupsPoint-in-time recovery: 3 days on Hobby, 7 days on ProScheduled volume backups; daily ones are kept for 6 daysIncluded in the plan: on DB-Starter, 1 a day kept for 7 days
Maximum volume on the entry planExpandable Postgres at US$ 0.30 per GB5 GB of volume on HobbyUp to 250 GB per PostgreSQL instance
MetricsService metrics on every workspaceMetrics in the dashboardFrom Premium up; real-time logs on every plan
PaymentCredit or debit card, in dollarsPostpaid card, in dollarsPIX, boleto, or card, in reais

Two Railway Hobby limits deserve attention for a production API. Volumes go up to 5 GB, so a growing database needs Pro. And since March 30, Railway requires a postpaid card and no longer accepts prepaid credits.

On Render, point-in-time recovery is the strong point of Postgres: you pick the minute you want to go back to within the plan’s window. On Zenifra, the automatic backup is included in the price, but restores are done by support, into a new project by default, and there is no recovery to an exact minute. For critical data, on all three platforms, also keep your own pg_dump stored outside the platform.

Where are the servers, and how much does that weigh on latency?

Both run outside South America. Render has regions in Oregon, Ohio, Virginia, Frankfurt, and Singapore. Railway has US West, in California, US East, in Virginia, EU West, in Amsterdam, and Southeast Asia, in Singapore. For an API used in Brazil, the best choice on both is Virginia, on the east coast of the United States.

How much does that cost in response time? In the benchmark Zenifra published, measured with Globalping on 11/06/2026, a new HTTPS connection from São Paulo reached the first byte in 18 ms on a server in São Paulo and in 378 ms on a server in Washington, in the same Virginia region. That is 360 ms of difference per new connection. From Rio de Janeiro the difference was 291 ms, and from Fortaleza, 142 ms.

On a connection that is already open, each request costs about one network round trip, which was 5 ms to São Paulo and 124 ms to Washington, measured from São Paulo. An app screen that opens one new connection and makes four more serial calls to the API waits about 874 ms with the API in Washington and 38 ms with the API in São Paulo.

Measured fromServer in São PauloServer in Washington (Virginia)Difference
São Paulo, new HTTPS connection18 ms378 ms360 ms
Rio de Janeiro, new HTTPS connection44 ms335 ms291 ms
Fortaleza, new HTTPS connection162 ms304 ms142 ms
São Paulo, round trip on an open connection5 ms124 ms119 ms

The benchmark used public AWS endpoints in both regions as a geographic reference, with 8 samples per city and region pair. For Render and Railway, Washington and Virginia serve as a reference for the US east coast, without confirming which provider each one runs on. The full method and the ID of every measurement are in the benchmark post.

Keep the API and the database in the same region, on any platform. If the API is in São Paulo and the database in Virginia, every query pays the round trip: 20 serial queries at about 124 ms each spend 2.5 seconds waiting for the database.

Is the Render or Railway free plan good enough to test the API?

It is good enough to test, but neither one works for production. On Render, the free web service spins down after 15 minutes without traffic, and the next request waits about a minute for it to come back up. The free Postgres expires 30 days after it is created, and each workspace gets 750 free instance hours a month.

On Railway, a new account gets a trial of up to 30 days with a one-time US$ 5 credit. Once the period ends or the credit is spent, the account moves to the Free plan, with US$ 1 of credit a month that does not roll over. On Free, each service can use up to 0.5 GB of memory and 0.5 GB of volume.

On Zenifra, the way to test is hourly billing: the API on Basic, with 0.5 vCPU and 512 MB, costs R$ 0.05 an hour, and PostgreSQL on DB-Starter costs R$ 0.018 an hour, plus disk. The application is not shut down for lack of traffic, and the database has a daily backup kept for 7 days. Sign-up asks for a Brazilian CPF or CNPJ, a mobile number, and an address in Brazil, and payment is by PIX, boleto, or card, in reais.

How much does the exchange rate change the bill in reais?

Enough for the same bill to move a few reais a month with no change to the API. With the 10/05/2026 PTAX selling rate of R$ 4.9859, Render’s US$ 13 came to R$ 67.09 with IOF. With the 11/09/2026 rate of R$ 5.5146, it comes to R$ 74.20. That is R$ 7.11 more a month, from the exchange rate alone.

On Railway there are two variables instead of one: the exchange rate and the dollar amount itself, which changes with usage. To budget, add a margin for the dollar and watch the usage dashboard during the first weeks. On top of the IOF, the card issuer applies its own spread over the rate, so the real bill tends to land a little above the numbers in this guide.

When is another platform better than Render and Railway?

When your users are in Brazil and you want to pay in reais. In that case, a platform with a region in São Paulo shortens every request and takes the exchange rate and IOF off the bill. On Zenifra, for example, the API and PostgreSQL run in São Paulo, billing is by PIX, boleto, or card, and the Basic plus DB-Starter pair costs R$ 42.00 a month.

It is also worth looking elsewhere when the API mostly serves content that rarely changes. A static front end behind a CDN, or serverless functions in a region close to the user, can cost less than keeping a process running. And if the team already runs servers, a VPS in São Paulo gives you more memory per real, with operations on you.

The reverse is also true, and worth saying. Render and Railway are better than a Brazilian platform when most users are in the United States, Europe, or Asia, because both have regions on three continents. Railway offers ready-made MySQL, MongoDB, and Redis, and Render has Key Value, cron jobs, workflows, and infrastructure as code with Blueprints. If your company already earns in dollars, exchange rate swings stop being a risk.

How do you move the API between Render, Railway, and Zenifra?

The application moves without code changes, as long as it reads the port and the database URL from environment variables. The work is in the database: export with pg_dump in custom format, restore with pg_restore at the destination, and only then switch the app’s DATABASE_URL variable. Do it during a low-traffic window and freeze writes during the copy.

The steps that work on all three platforms are four. Create the database at the destination in the same region as the application. Export the source database through its external connection. Restore at the destination and check the row count of the main tables. Finally, deploy the application at the destination with the same variables, point the domain, and keep the source running for a few days so you can roll back if something goes wrong.

bash
# 1. Export the source database (Render or Railway)
pg_dump "$SOURCE_DATABASE_URL" --format=custom --no-owner --file=backup.dump

# 2. Restore into the destination database
pg_restore --no-owner --dbname="$TARGET_DATABASE_URL" backup.dump

# 3. Check an important table on both sides
psql "$SOURCE_DATABASE_URL" -c "select count(*) from orders"
psql "$TARGET_DATABASE_URL" -c "select count(*) from orders"

On Render, the external database URL is on the Postgres page. On Railway, use the DATABASE_PUBLIC_URL variable of the database service. On Zenifra, PostgreSQL connections require TLS, so keep the sslmode parameter in the destination URL.

In short

For a small API in production, Render is the pick for a predictable bill, at US$ 13 a month for the 512 MB instance and the smallest paid Postgres, and Railway is the pick for low, irregular usage when you prefer to pay for consumption, which came to US$ 12.65 in our example. For a team, Railway Pro tends to cost less than Render Pro, because the subscription turns into credit. In both cases, the API runs in Virginia and the bill comes in dollars, with exchange rate and IOF.

If your users are in Brazil, it is worth running the same numbers with a platform in São Paulo, and the Zenifra calculator shows your scenario in reais.

Estimate my cost in reais

We respect your privacy

We use essential cookies to run this site. Measurement and marketing cookies, such as Google Ads, are only enabled when you accept all cookies. Read our cookie policy.