Consumir la API en tus proyectos
¿Qué es JSON?, ¿Cómo consumir la API en mis proyectos?, ¿Qué lenguajes puedo usar? y otras preguntas sobre findic.cl.
¿Qué es JSON?
JSON o JavaScript Object Notation, es un formato de texto sencillo utilizado en el intercambio de información a través de internet, especialmente utilizada en aplicaciones móviles y WEB gracias a su facilidad de lectura y su formato estructurado.
Un objeto JSON, se compone principalmente de atributos “clave”: “valor”, un valor puede ser de tipo numérico, texto, listas e incluso otros objetos complejos.
¿Cómo consumir la API en mis proyectos?
Puedes consumir esta API desde cualquier aplicación o componente de software; desde una Aplicación móvil, solicitándolo desde el backend en un servidor o puedes consultar directamente desde tu página web utilizando JavaScript.
¿Tiene un costo?
NO necesitas pagar por utilizar esta API; su uso es completamente gratuito.
¿Necesito un usuario o llave para hacer consultas la API?
NO necesitas tener un usuario, ni utilizar llaves para realizar las consultas. La API es completamente pública y transparente.
¿Qué lenguajes puedo usar?
Puedes utilizar cualquier lenguaje que te permita realizar consultas http (HTTPS) a nuestra API, luego depende de cada lenguaje elegir un mecanismo para transformar/decodificar el JSON a un objeto utilizable (parse, deserialize, etc).
Cabeceras recomendadas
Los ejemplos envían la cabecera User-Agent con un identificador del lenguaje o de la aplicación, por ejemplo findic-docs-java/1.0, salvo en los navegadores, donde el User-Agent lo controla el navegador. Si estás desarrollando una aplicación, reemplázala por el nombre y la versión de tu proyecto (por ejemplo mi-app/2.1.0), así podemos identificar el origen de las consultas.
También recomendamos enviar Accept: application/json para indicar que esperamos un objeto JSON.
En el navegador, JavaScript no permite modificar la cabecera User-Agent; en ese caso el navegador enviará la suya y no es posible cambiarla desde el código.
Ejemplos por lenguaje
1 - PHP
Uso de PHP (Personal Home Page) para obtener datos desde la API de indicadores.
A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje PHP. El ejemplo utiliza cURL y envía la cabecera User-Agent para identificar el cliente.
<?php
$apiUrl = 'https://findic.cl/api/';
$curl = curl_init($apiUrl);
curl_setopt_array($curl, [
CURLOPT_RETURNTRANSFER => true,
CURLOPT_CONNECTTIMEOUT => 5,
CURLOPT_TIMEOUT => 10,
CURLOPT_USERAGENT => 'findic-docs-php/1.0',
CURLOPT_HTTPHEADER => [
'Accept: application/json',
],
]);
$json = curl_exec($curl);
$status = curl_getinfo($curl, CURLINFO_HTTP_CODE);
$error = curl_error($curl);
if ($json === false || $status !== 200) {
exit('Error en la solicitud: ' . ($error !== '' ? $error : $status));
}
try {
// Decodificamos el JSON y lo transformamos en objeto
$dailyIndicators = json_decode($json, false, 512, JSON_THROW_ON_ERROR);
} catch (JsonException $exception) {
exit('Error al decodificar el JSON: ' . $exception->getMessage());
}
// Imprimimos el dato de la UF
echo 'El valor actual de la UF es $' . $dailyIndicators->uf->valor;
Si tu servidor no tiene cURL habilitado, puedes usar file_get_contents con un contexto de flujo que incluya las mismas cabeceras User-Agent y Accept.
Más información del objeto JSON entregado en el resumen aquí.
2 - JavaScript
Uso de JavaScript para obtener datos desde la API de indicadores.
A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje JavaScript, este ejemplo te puede ser útil si lo quieres utilizar en tu página web y quieres actualizar el HTML directamente.
async function obtenerUF() {
try {
const response = await fetch("https://findic.cl/api/", {
// Solo recibiremos un objeto JSON
headers: {
Accept: "application/json",
},
// El método de solicitud que realizaremos (un GET)
method: "GET",
});
// Verificamos que la respuesta sea correcta antes de leer el JSON
if (!response.ok) {
throw new Error(`Error en la solicitud: ${response.status}`);
}
const data = await response.json();
// Obtenemos el elemento de nuestro HTML que contenga el ID "UF"
// (por ejemplo <div id="UF"></div>) y le asignamos el valor de la UF
document.getElementById("UF").textContent = data.uf.valor;
} catch (error) {
console.error(error);
}
}
obtenerUF();
En el navegador no es posible modificar la cabecera User-Agent, ya que el navegador la controla por seguridad. Si consumes la API desde Node.js, Deno o Bun, agrega "User-Agent": "findic-docs-js/1.0" a las cabeceras de la solicitud.
La cabecera Access-Control-Allow-Origin es una cabecera de respuesta que configura el servidor; no es necesario enviarla desde el cliente.
Más información del objeto JSON entregado en el resumen aquí.
3 - TypeScript
Uso de TypeScript para obtener datos desde la API de indicadores.
A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje TypeScript. El ejemplo utiliza fetch, disponible de forma nativa en Node.js 18+, Deno y Bun, y envía la cabecera User-Agent para identificar el cliente.
interface Indicador {
codigo: string;
nombre: string;
unidad_medida: string;
fecha: string;
valor: number;
}
interface Resumen {
version: string;
autor: string;
fecha: string;
uf: Indicador;
}
async function obtenerResumen(): Promise<Resumen> {
const response = await fetch("https://findic.cl/api/", {
method: "GET",
headers: {
"User-Agent": "findic-docs-typescript/1.0",
"Accept": "application/json",
},
});
if (!response.ok) {
throw new Error(`Error en la solicitud: ${response.status}`);
}
return (await response.json()) as Resumen;
}
obtenerResumen()
.then((data) => {
console.log(`Fecha: ${data.uf.fecha}`);
console.log(`Valor UF: $ ${data.uf.valor}`);
})
.catch((error) => console.error(error));
En el navegador, User-Agent es una cabecera prohibida y no se puede modificar desde JavaScript o TypeScript; el navegador enviará la suya. En Node.js 18+ fetch está disponible de forma nativa; si tu configuración de TypeScript no lo reconoce, agrega "DOM" a la opción lib de tu tsconfig.json o instala @types/node.
Más información del objeto JSON entregado en el resumen aquí.
4 - Python
Uso de Python para obtener datos desde la API de indicadores.
A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje Python. El ejemplo utiliza requests, reutiliza una sesión y envía la cabecera User-Agent para identificar el cliente.
Si aún no tienes requests, instálalo con:
import requests
# Endpoint de la API para obtener el resumen diario
url = "https://findic.cl/api/"
# Reutilizamos una sesión para enviar las mismas cabeceras en cada consulta
with requests.Session() as session:
session.headers.update({
"User-Agent": "findic-docs-python/1.0",
"Accept": "application/json",
})
try:
response = session.get(url, timeout=10)
response.raise_for_status()
data = response.json()
# Obtenemos el valor de UF
uf = data["uf"]
print(f"Fecha: {uf['fecha']}")
print(f"Valor UF: $ {uf['valor']}")
except requests.RequestException as error:
print(f"Error en la solicitud: {error}")
Más información del objeto JSON entregado en el resumen aquí.
5 - Ruby
Uso de Ruby para obtener datos desde la API de indicadores.
A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje Ruby. El ejemplo utiliza Net::HTTP, incluido en la librería estándar, y envía la cabecera User-Agent para identificar el cliente.
require "json"
require "net/http"
uri = URI("https://findic.cl/api/")
request = Net::HTTP::Get.new(uri)
request["User-Agent"] = "findic-docs-ruby/1.0"
request["Accept"] = "application/json"
http = Net::HTTP.new(uri.hostname, uri.port)
http.use_ssl = uri.scheme == "https"
http.open_timeout = 10
http.read_timeout = 10
begin
response = http.start { |connection| connection.request(request) }
if response.is_a?(Net::HTTPSuccess)
data = JSON.parse(response.body)
uf = data["uf"]
puts "Fecha: #{uf['fecha']}"
puts "Valor UF: $ #{uf['valor']}"
else
warn "Error en la solicitud: #{response.code}"
end
rescue StandardError => error
warn "Error en la solicitud: #{error.message}"
end
Más información del objeto JSON entregado en el resumen aquí.
6 - R
Uso de R para obtener datos desde la API de indicadores.
A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje R. El ejemplo utiliza httr2 y envía la cabecera User-Agent para identificar el cliente.
Instala los paquetes si aún no los tienes:
install.packages(c("httr2", "jsonlite"))
library(httr2)
url <- "https://findic.cl/api/"
tryCatch(
{
respuesta <- request(url) |>
req_user_agent("findic-docs-r/1.0") |>
req_headers(Accept = "application/json") |>
req_timeout(10) |>
req_perform()
resumen <- resp_body_json(respuesta)
uf <- resumen$uf
cat("Fecha:", uf$fecha, "\n")
cat("Valor UF: $", uf$valor, "\n")
},
error = function(error) {
cat("Error en la solicitud:", conditionMessage(error), "\n")
}
)
Más información del objeto JSON entregado en el resumen aquí.
7 - Java
Uso de Java para obtener datos desde la API de indicadores.
A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje Java. El ejemplo utiliza java.net.http.HttpClient, incluido desde Java 11, y Jackson para leer el JSON. Además, envía la cabecera User-Agent para identificar el cliente.
Si usas Maven, agrega la dependencia de Jackson:
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.18.2</version>
</dependency>
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
public class FindicExample {
public static void main(String[] args) throws Exception {
HttpClient client = HttpClient.newBuilder()
.connectTimeout(Duration.ofSeconds(10))
.followRedirects(HttpClient.Redirect.NORMAL)
.build();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://findic.cl/api/"))
.timeout(Duration.ofSeconds(10))
.header("User-Agent", "findic-docs-java/1.0")
.header("Accept", "application/json")
.GET()
.build();
HttpResponse<String> response = client.send(
request,
HttpResponse.BodyHandlers.ofString()
);
if (response.statusCode() != 200) {
System.err.println("Error en la solicitud: " + response.statusCode());
return;
}
JsonNode data = new ObjectMapper().readTree(response.body());
JsonNode uf = data.get("uf");
System.out.println("Fecha: " + uf.get("fecha").asText());
System.out.println("Valor UF: $ " + uf.get("valor").asDouble());
}
}
Más información del objeto JSON entregado en el resumen aquí.
8 - Kotlin
Uso de Kotlin para obtener datos desde la API de indicadores.
A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje Kotlin. El ejemplo está pensado para Kotlin/JVM, por lo que funciona en Android, backend o aplicaciones de escritorio. Utiliza OkHttp y kotlinx.serialization, y envía la cabecera User-Agent para identificar el cliente.
Agrega las dependencias y el plugin de serialización a tu proyecto:
plugins {
kotlin("jvm") version "2.4.21"
kotlin("plugin.serialization") version "2.4.21"
}
dependencies {
implementation("com.squareup.okhttp3:okhttp:4.12.0")
implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.3")
}
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import okhttp3.OkHttpClient
import okhttp3.Request
import java.util.concurrent.TimeUnit
@Serializable
data class Indicador(
val fecha: String,
val valor: Double,
)
@Serializable
data class Resumen(
val uf: Indicador,
)
fun main() {
val client = OkHttpClient.Builder()
.connectTimeout(10, TimeUnit.SECONDS)
.readTimeout(10, TimeUnit.SECONDS)
.build()
val request = Request.Builder()
.url("https://findic.cl/api/")
.header("User-Agent", "findic-docs-kotlin/1.0")
.header("Accept", "application/json")
.get()
.build()
try {
client.newCall(request).execute().use { response ->
if (!response.isSuccessful) {
error("Error en la solicitud: ${response.code}")
}
val body = response.body?.string() ?: error("Respuesta vacía")
val json = Json { ignoreUnknownKeys = true }
val resumen = json.decodeFromString<Resumen>(body)
println("Fecha: ${resumen.uf.fecha}")
println("Valor UF: $ ${resumen.uf.valor}")
}
} catch (exception: Exception) {
println("Error en la solicitud: ${exception.message}")
}
}
En Android, recuerda agregar <uses-permission android:name="android.permission.INTERNET" /> en el AndroidManifest.xml.
Más información del objeto JSON entregado en el resumen aquí.
9 - C#
Uso de C# (.NET) para obtener datos desde la API de indicadores.
A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje C#. El ejemplo utiliza HttpClient y System.Text.Json, incluidos en .NET, y envía la cabecera User-Agent para identificar el cliente.
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text.Json;
using System.Threading.Tasks;
class Program
{
// Reutilizamos una sola instancia de HttpClient durante toda la aplicación
private static readonly HttpClient Client = new HttpClient
{
Timeout = TimeSpan.FromSeconds(10)
};
static async Task Main()
{
Client.DefaultRequestHeaders.UserAgent.ParseAdd("findic-docs-dotnet/1.0");
Client.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue("application/json")
);
try
{
using HttpResponseMessage response = await Client.GetAsync(
"https://findic.cl/api/"
);
response.EnsureSuccessStatusCode();
string json = await response.Content.ReadAsStringAsync();
using JsonDocument document = JsonDocument.Parse(json);
JsonElement uf = document.RootElement.GetProperty("uf");
Console.WriteLine($"Fecha: {uf.GetProperty("fecha").GetString()}");
Console.WriteLine($"Valor UF: $ {uf.GetProperty("valor").GetDecimal()}");
}
catch (HttpRequestException error)
{
Console.WriteLine($"Error en la solicitud: {error.Message}");
}
}
}
Más información del objeto JSON entregado en el resumen aquí.
10 - Go
Uso de Go para obtener datos desde la API de indicadores.
A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje Go. El ejemplo utiliza la librería estándar net/http y envía la cabecera User-Agent para identificar el cliente.
package main
import (
"context"
"encoding/json"
"fmt"
"net/http"
"time"
)
type Indicador struct {
Fecha string `json:"fecha"`
Valor float64 `json:"valor"`
}
type Resumen struct {
UF Indicador `json:"uf"`
}
func main() {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
req, err := http.NewRequestWithContext(
ctx,
http.MethodGet,
"https://findic.cl/api/",
nil,
)
if err != nil {
fmt.Println("Error al crear la solicitud:", err)
return
}
req.Header.Set("User-Agent", "findic-docs-go/1.0")
req.Header.Set("Accept", "application/json")
client := &http.Client{Timeout: 10 * time.Second}
resp, err := client.Do(req)
if err != nil {
fmt.Println("Error en la solicitud:", err)
return
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
fmt.Println("Error en la solicitud:", resp.StatusCode)
return
}
var resumen Resumen
if err := json.NewDecoder(resp.Body).Decode(&resumen); err != nil {
fmt.Println("Error al decodificar el JSON:", err)
return
}
fmt.Println("Fecha:", resumen.UF.Fecha)
fmt.Printf("Valor UF: $ %.2f\n", resumen.UF.Valor)
}
Más información del objeto JSON entregado en el resumen aquí.
11 - Rust
Uso de Rust para obtener datos desde la API de indicadores.
A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje Rust. El ejemplo utiliza reqwest y serde, y envía la cabecera User-Agent para identificar el cliente.
Agrega las dependencias a tu Cargo.toml:
[dependencies]
reqwest = { version = "0.12", features = ["blocking", "json"] }
serde = { version = "1", features = ["derive"] }
use reqwest::blocking::Client;
use serde::Deserialize;
use std::time::Duration;
#[derive(Debug, Deserialize)]
struct Indicador {
fecha: String,
valor: f64,
}
#[derive(Debug, Deserialize)]
struct Resumen {
uf: Indicador,
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = Client::builder()
.user_agent("findic-docs-rust/1.0")
.timeout(Duration::from_secs(10))
.build()?;
let resumen: Resumen = client
.get("https://findic.cl/api/")
.header(reqwest::header::ACCEPT, "application/json")
.send()?
.error_for_status()?
.json()?;
println!("Fecha: {}", resumen.uf.fecha);
println!("Valor UF: $ {:.2}", resumen.uf.valor);
Ok(())
}
Más información del objeto JSON entregado en el resumen aquí.
12 - Swift
Uso de Swift para obtener datos desde la API de indicadores.
A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje Swift. El ejemplo utiliza URLSession y Codable, y envía la cabecera User-Agent para identificar el cliente.
import Foundation
struct Indicador: Decodable {
let fecha: String
let valor: Double
}
struct Resumen: Decodable {
let uf: Indicador
}
@main
struct FindicExample {
static func main() async {
guard let url = URL(string: "https://findic.cl/api/") else {
print("URL inválida")
return
}
let configuration = URLSessionConfiguration.default
configuration.httpAdditionalHeaders = [
"User-Agent": "findic-docs-swift/1.0",
"Accept": "application/json"
]
configuration.timeoutIntervalForRequest = 10
let session = URLSession(configuration: configuration)
do {
let (data, response) = try await session.data(from: url)
guard let httpResponse = response as? HTTPURLResponse,
httpResponse.statusCode == 200 else {
print("Error en la solicitud")
return
}
let resumen = try JSONDecoder().decode(Resumen.self, from: data)
print("Fecha: \(resumen.uf.fecha)")
print("Valor UF: $ \(resumen.uf.valor)")
} catch {
print("Error en la solicitud: \(error)")
}
}
}
El ejemplo utiliza async/await y URLSession.data(from:), disponibles desde iOS 15, macOS 12 y Swift 5.5.
Si compilas el ejemplo como un ejecutable de un solo archivo, agrega -parse-as-library a swiftc; de lo contrario, @main se considera código de nivel superior.
Más información del objeto JSON entregado en el resumen aquí.
13 - Flutter (Dart)
Uso de Flutter (Dart) para obtener datos desde la API de indicadores.
A continuación se muestra el código de ejemplo para consultar a nuestra API desde Flutter. El ejemplo utiliza el paquete http y envía la cabecera User-Agent para identificar el cliente.
Agrega la dependencia a tu proyecto:
import 'dart:convert';
import 'package:http/http.dart' as http;
Future<void> main() async {
final uri = Uri.parse('https://findic.cl/api/');
try {
final response = await http.get(
uri,
headers: {
'User-Agent': 'findic-docs-flutter/1.0',
'Accept': 'application/json',
},
);
if (response.statusCode != 200) {
print('Error en la solicitud: ${response.statusCode}');
return;
}
final data = jsonDecode(response.body) as Map<String, dynamic>;
final uf = data['uf'] as Map<String, dynamic>;
print('Fecha: ${uf['fecha']}');
print('Valor UF: \$ ${uf['valor']}');
} catch (error) {
print('Error en la solicitud: $error');
}
}
En Flutter Web el navegador controla la cabecera User-Agent y no es posible modificarla desde Dart. En Android, iOS, macOS, Windows y Linux sí se envía la cabecera indicada.
Más información del objeto JSON entregado en el resumen aquí.
14 - Lazarus
Uso de Lazarus (Free Pascal) para obtener datos desde la API de indicadores.
A continuación se muestra el código de ejemplo para consultar a nuestra API desde Lazarus (Free Pascal). El ejemplo utiliza TFPHTTPClient y fpjson, incluidos en Lazarus, y envía la cabecera User-Agent para identificar el cliente.
program FindicExample;
{$mode objfpc}{$H+}
uses
SysUtils, fphttpclient, fpjson, jsonparser, opensslsockets;
var
Client: TFPHTTPClient;
JSONValue: TJSONData;
Resumen: TJSONObject;
UF: TJSONObject;
begin
Client := TFPHTTPClient.Create(nil);
try
Client.AddHeader('User-Agent', 'findic-docs-lazarus/1.0');
Client.AddHeader('Accept', 'application/json');
Client.ConnectTimeout := 10000;
Client.IOTimeout := 10000;
try
JSONValue := GetJSON(Client.Get('https://findic.cl/api/'));
if not (JSONValue is TJSONObject) then
begin
JSONValue.Free;
Writeln('Error al decodificar el JSON');
Exit;
end;
Resumen := TJSONObject(JSONValue);
try
UF := Resumen.Objects['uf'];
Writeln('Fecha: ', UF.Strings['fecha']);
Writeln('Valor UF: $ ', UF.Floats['valor']:0:2);
finally
Resumen.Free;
end;
except
on E: Exception do
Writeln('Error en la solicitud: ', E.Message);
end;
finally
Client.Free;
end;
end.
Más información del objeto JSON entregado en el resumen aquí.
En macOS con Homebrew, si aparece Could not initialize OpenSSL library, instala openssl@1.1 (brew install openssl@1.1) y ejecuta el programa con DYLD_LIBRARY_PATH="$(brew --prefix openssl@1.1)/lib".