import os
import requests
url = "https://slack.com/api/files.upload"
headers = {
"Authorization": f"Bearer {os.environ['SLACK_BOT_TOKEN']}"
}
files = {
"file": open("document.pdf", "rb")
}
form_data = {
"channels": "C12345678"
}
response = requests.post(url, headers=headers, files=files, data=form_data)
response.raise_for_status()
print(response.json())
import os
import httpx
url = "https://slack.com/api/files.upload"
headers = {
"Authorization": f"Bearer {os.environ['SLACK_BOT_TOKEN']}"
}
files = {
"file": open("document.pdf", "rb")
}
form_data = {
"channels": "C12345678"
}
with httpx.Client() as client:
response = client.post(url, headers=headers, files=files, data=form_data)
response.raise_for_status()
print(response.json())
import { readFileSync } from 'fs';
import fetch from 'node-fetch';
const url = 'https://slack.com/api/files.upload';
const headers = {
'Authorization': `Bearer ${process.env.SLACK_BOT_TOKEN}`
};
const formData = new FormData();
formData.append('file', readFileSync('document.pdf'));
formData.append('channels', 'C12345678');
fetch(url, {
method: 'POST',
headers,
body: formData
})
.then(res => res.json())
.then(console.log)
.catch(console.error);
import axios from 'axios';
import FormData from 'form-data';
import { readFileSync } from 'fs';
const url = 'https://slack.com/api/files.upload';
const headers = {
'Authorization': `Bearer ${process.env.SLACK_BOT_TOKEN}`
};
const form = new FormData();
form.append('file', readFileSync('document.pdf'));
form.append('channels', 'C12345678');
axios.post(url, form, { headers: { ...headers, ...form.getHeaders() } })
.then(res => console.log(res.data))
.catch(err => console.error(err));
package main
import (
"bytes"
"fmt"
"io"
"mime/multipart"
"net/http"
"os"
)
func main() {
url := "https://slack.com/api/files.upload"
token := os.Getenv("SLACK_BOT_TOKEN")
body := &bytes.Buffer{}
writer := multipart.NewWriter(body)
file, err := os.Open("document.pdf")
if err != nil {
panic(err)
}
defer file.Close()
part, err := writer.CreateFormFile("file", "document.pdf")
if err != nil {
panic(err)
}
_, err = io.Copy(part, file)
if err != nil {
panic(err)
}
_ = writer.WriteField("channels", "C12345678")
writer.Close()
req, err := http.NewRequest("POST", url, body)
if err != nil {
panic(err)
}
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))
req.Header.Set("Content-Type", writer.FormDataContentType())
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
panic(fmt.Sprintf("unexpected status: %s", resp.Status))
}
fmt.Println(resp.Body)
}
<?php
$url = 'https://slack.com/api/files.upload';
$token = getenv('SLACK_BOT_TOKEN');
$client = new CURLFile('document.pdf', 'application/pdf', 'document.pdf');
$post = [
'file' => $client,
'channels' => 'C12345678'
];
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $post);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Authorization: Bearer ' . $token
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
if (curl_errno($ch)) {
die(curl_error($ch));
}
curl_close($ch);
print_r(json_decode($response, true));
require 'net/http'
require 'uri'
require 'mime/types'
url = URI.parse('https://slack.com/api/files.upload')
token = ENV['SLACK_BOT_TOKEN']
file_path = 'document.pdf'
file = File.open(file_path, 'rb')
req = Net::HTTP::Post::Multipart.new(url.path, {
file: UploadIO.new(file, MIME::Types.type_for(file_path).first.to_s, file_path),
channels: 'C12345678'
})
req['Authorization'] = "Bearer #{token}"
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(req)
puts response.body
import Foundation
let url = URL(string: "https://slack.com/api/files.upload")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer \(ProcessInfo.processInfo.environment["SLACK_BOT_TOKEN"] ?? "")", forHTTPHeaderField: "Authorization")
let boundary = UUID().uuidString
request.setValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")
var body = Data()
let fileData = try Data(contentsOf: URL(fileURLWithPath: "document.pdf"))
body.append("--\(boundary)\r\n".data(using: .utf8)!)
body.append("Content-Disposition: form-data; name=\"file\"; filename=\"document.pdf\"\r\n".data(using: .utf8)!)
body.append("Content-Type: application/pdf\r\n\r\n".data(using: .utf8)!)
body.append(fileData)
body.append("\r\n".data(using: .utf8)!)
body.append("--\(boundary)\r\n".data(using: .utf8)!)
body.append("Content-Disposition: form-data; name=\"channels\"\r\n\r\n".data(using: .utf8)!)
body.append("C12345678\r\n".data(using: .utf8)!)
body.append("--\(boundary)--\r\n".data(using: .utf8)!)
request.httpBody = body
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print(error)
return
}
guard let data = data else {
print("No data received")
return
}
if let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
print(json)
}
}
task.resume()
RunLoop.main.run()
use reqwest::blocking::Client;
use std::env;
use std::fs::File;
use std::io::Read;
fn main() -> Result<(), Box<dyn std::error::Error>> {
let url = "https://slack.com/api/files.upload";
let token = env::var("SLACK_BOT_TOKEN")?;
let mut file = File::open("document.pdf")?;
let mut buffer = Vec::new();
file.read_to_end(&mut buffer)?;
let form = reqwest::blocking::multipart::Form::new()
.file("file", "document.pdf")?
.text("channels", "C12345678");
let client = Client::new();
let response = client
.post(url)
.header("Authorization", format!("Bearer {}", token))
.multipart(form)
.send()?;
if !response.status().is_success() {
return Err(format!("Request failed: {}", response.status()).into());
}
let body = response.text()?;
println!("{}", body);
Ok(())
}
using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main()
{
var url = "https://slack.com/api/files.upload";
var token = Environment.GetEnvironmentVariable("SLACK_BOT_TOKEN");
using var client = new HttpClient();
using var form = new MultipartFormDataContent();
var fileStream = File.OpenRead("document.pdf");
var streamContent = new StreamContent(fileStream);
var fileContent = new ByteArrayContent(await streamContent.ReadAsByteArrayAsync());
fileContent.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/pdf");
form.Add(fileContent, "file", "document.pdf");
form.Add(new StringContent("C12345678"), "channels");
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", token);
var response = await client.PostAsync(url, form);
response.EnsureSuccessStatusCode();
var responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
}